src/mesa/drivers/dri/i965/brw_fs_visitor.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 DEALINGS
  21  * IN THE SOFTWARE.
  22  */
  23
  24 /** @file brw_fs_visitor.cpp
  25  *
  26  * This file supports generating the FS LIR from the GLSL IR.  The LIR
  27  * makes it easier to do backend-specific optimizations than doing so
  28  * in the GLSL IR or in the native code.
  29  */
  30 extern "C" {
  31
  32 #include <sys/types.h>
  33
  34 #include "main/macros.h"
  35 #include "main/shaderobj.h"
  36 #include "program/prog_parameter.h"
  37 #include "program/prog_print.h"
  38 #include "program/prog_optimize.h"
  39 #include "program/register_allocate.h"
  40 #include "program/sampler.h"
  41 #include "program/hash_table.h"
  42 #include "brw_context.h"
  43 #include "brw_eu.h"
  44 #include "brw_wm.h"
  45 }
  46 #include "brw_fs.h"
  47 #include "main/uniforms.h"
  48 #include "glsl/glsl_types.h"
  49 #include "glsl/ir_optimization.h"
  50
  51 void
  52 fs_visitor::visit(ir_variable *ir)
  53 {
  54    fs_reg *reg = NULL;
  55
  56    if (variable_storage(ir))
  57       return;
  58
  59    if (ir->mode == ir_var_shader_in) {
  60       if (!strcmp(ir->name, "gl_FragCoord")) {
  61          reg = emit_fragcoord_interpolation(ir);
  62       } else if (!strcmp(ir->name, "gl_FrontFacing")) {
  63          reg = emit_frontfacing_interpolation(ir);
  64       } else {
  65          reg = emit_general_interpolation(ir);
  66       }
  67       assert(reg);
  68       hash_table_insert(this->variable_ht, reg, ir);
  69       return;
  70    } else if (ir->mode == ir_var_shader_out) {
  71       reg = new(this->mem_ctx) fs_reg(this, ir->type);
  72
  73       if (ir->index > 0) {
  74          assert(ir->location == FRAG_RESULT_DATA0);
  75          assert(ir->index == 1);
  76          this->dual_src_output = *reg;
  77       } else if (ir->location == FRAG_RESULT_COLOR) {
  78          /* Writing gl_FragColor outputs to all color regions. */
  79          for (unsigned int i = 0; i < MAX2(c->key.nr_color_regions, 1); i++) {
  80             this->outputs[i] = *reg;
  81             this->output_components[i] = 4;
  82          }
  83       } else if (ir->location == FRAG_RESULT_DEPTH) {
  84          this->frag_depth = *reg;
  85       } else {
  86          /* gl_FragData or a user-defined FS output */
  87          assert(ir->location >= FRAG_RESULT_DATA0 &&
  88                 ir->location < FRAG_RESULT_DATA0 + BRW_MAX_DRAW_BUFFERS);
  89
  90          int vector_elements =
  91             ir->type->is_array() ? ir->type->fields.array->vector_elements
  92                                  : ir->type->vector_elements;
  93
  94          /* General color output. */
  95          for (unsigned int i = 0; i < MAX2(1, ir->type->length); i++) {
  96             int output = ir->location - FRAG_RESULT_DATA0 + i;
  97             this->outputs[output] = *reg;
  98             this->outputs[output].reg_offset += vector_elements * i;
  99             this->output_components[output] = vector_elements;
 100          }
 101       }
 102    } else if (ir->mode == ir_var_uniform) {
 103       int param_index = c->prog_data.nr_params;
 104
 105       /* Thanks to the lower_ubo_reference pass, we will see only
 106        * ir_binop_ubo_load expressions and not ir_dereference_variable for UBO
 107        * variables, so no need for them to be in variable_ht.
 108        */
 109       if (ir->is_in_uniform_block())
 110          return;
 111
 112       if (dispatch_width == 16) {
 113          if (!variable_storage(ir)) {
 114             fail("Failed to find uniform '%s' in 16-wide\n", ir->name);
 115          }
 116          return;
 117       }
 118
 119       param_size[param_index] = type_size(ir->type);
 120       if (!strncmp(ir->name, "gl_", 3)) {
 121          setup_builtin_uniform_values(ir);
 122       } else {
 123          setup_uniform_values(ir);
 124       }
 125
 126       reg = new(this->mem_ctx) fs_reg(UNIFORM, param_index);
 127       reg->type = brw_type_for_base_type(ir->type);
 128    }
 129
 130    if (!reg)
 131       reg = new(this->mem_ctx) fs_reg(this, ir->type);
 132
 133    hash_table_insert(this->variable_ht, reg, ir);
 134 }
 135
 136 void
 137 fs_visitor::visit(ir_dereference_variable *ir)
 138 {
 139    fs_reg *reg = variable_storage(ir->var);
 140    this->result = *reg;
 141 }
 142
 143 void
 144 fs_visitor::visit(ir_dereference_record *ir)
 145 {
 146    const glsl_type *struct_type = ir->record->type;
 147
 148    ir->record->accept(this);
 149
 150    unsigned int offset = 0;
 151    for (unsigned int i = 0; i < struct_type->length; i++) {
 152       if (strcmp(struct_type->fields.structure[i].name, ir->field) == 0)
 153          break;
 154       offset += type_size(struct_type->fields.structure[i].type);
 155    }
 156    this->result.reg_offset += offset;
 157    this->result.type = brw_type_for_base_type(ir->type);
 158 }
 159
 160 void
 161 fs_visitor::visit(ir_dereference_array *ir)
 162 {
 163    ir_constant *constant_index;
 164    fs_reg src;
 165    int element_size = type_size(ir->type);
 166
 167    constant_index = ir->array_index->as_constant();
 168
 169    ir->array->accept(this);
 170    src = this->result;
 171    src.type = brw_type_for_base_type(ir->type);
 172
 173    if (constant_index) {
 174       assert(src.file == UNIFORM || src.file == GRF);
 175       src.reg_offset += constant_index->value.i[0] * element_size;
 176    } else {
 177       /* Variable index array dereference.  We attach the variable index
 178        * component to the reg as a pointer to a register containing the
 179        * offset.  Currently only uniform arrays are supported in this patch,
 180        * and that reladdr pointer is resolved by
 181        * move_uniform_array_access_to_pull_constants().  All other array types
 182        * are lowered by lower_variable_index_to_cond_assign().
 183        */
 184       ir->array_index->accept(this);
 185
 186       fs_reg index_reg;
 187       index_reg = fs_reg(this, glsl_type::int_type);
 188       emit(BRW_OPCODE_MUL, index_reg, this->result, fs_reg(element_size));
 189
 190       if (src.reladdr) {
 191          emit(BRW_OPCODE_ADD, index_reg, *src.reladdr, index_reg);
 192       }
 193
 194       src.reladdr = ralloc(mem_ctx, fs_reg);
 195       memcpy(src.reladdr, &index_reg, sizeof(index_reg));
 196    }
 197    this->result = src;
 198 }
 199
 200 void
 201 fs_visitor::emit_lrp(fs_reg dst, fs_reg x, fs_reg y, fs_reg a)
 202 {
 203    if (brw->gen < 6 ||
 204        !x.is_valid_3src() ||
 205        !y.is_valid_3src() ||
 206        !a.is_valid_3src()) {
 207       /* We can't use the LRP instruction.  Emit x*(1-a) + y*a. */
 208       fs_reg y_times_a           = fs_reg(this, glsl_type::float_type);
 209       fs_reg one_minus_a         = fs_reg(this, glsl_type::float_type);
 210       fs_reg x_times_one_minus_a = fs_reg(this, glsl_type::float_type);
 211
 212       emit(MUL(y_times_a, y, a));
 213
 214       a.negate = !a.negate;
 215       emit(ADD(one_minus_a, a, fs_reg(1.0f)));
 216       emit(MUL(x_times_one_minus_a, x, one_minus_a));
 217
 218       emit(ADD(dst, x_times_one_minus_a, y_times_a));
 219    } else {
 220       /* The LRP instruction actually does op1 * op0 + op2 * (1 - op0), so
 221        * we need to reorder the operands.
 222        */
 223       emit(LRP(dst, a, y, x));
 224    }
 225 }
 226
 227 void
 228 fs_visitor::emit_minmax(uint32_t conditionalmod, fs_reg dst,
 229                         fs_reg src0, fs_reg src1)
 230 {
 231    fs_inst *inst;
 232
 233    if (brw->gen >= 6) {
 234       inst = emit(BRW_OPCODE_SEL, dst, src0, src1);
 235       inst->conditional_mod = conditionalmod;
 236    } else {
 237       emit(CMP(reg_null_d, src0, src1, conditionalmod));
 238
 239       inst = emit(BRW_OPCODE_SEL, dst, src0, src1);
 240       inst->predicate = BRW_PREDICATE_NORMAL;
 241    }
 242 }
 243
 244 /* Instruction selection: Produce a MOV.sat instead of
 245  * MIN(MAX(val, 0), 1) when possible.
 246  */
 247 bool
 248 fs_visitor::try_emit_saturate(ir_expression *ir)
 249 {
 250    ir_rvalue *sat_val = ir->as_rvalue_to_saturate();
 251
 252    if (!sat_val)
 253       return false;
 254
 255    fs_inst *pre_inst = (fs_inst *) this->instructions.get_tail();
 256
 257    sat_val->accept(this);
 258    fs_reg src = this->result;
 259
 260    fs_inst *last_inst = (fs_inst *) this->instructions.get_tail();
 261
 262    /* If the last instruction from our accept() didn't generate our
 263     * src, generate a saturated MOV
 264     */
 265    fs_inst *modify = get_instruction_generating_reg(pre_inst, last_inst, src);
 266    if (!modify || modify->regs_written != 1) {
 267       this->result = fs_reg(this, ir->type);
 268       fs_inst *inst = emit(MOV(this->result, src));
 269       inst->saturate = true;
 270    } else {
 271       modify->saturate = true;
 272       this->result = src;
 273    }
 274
 275
 276    return true;
 277 }
 278
 279 bool
 280 fs_visitor::try_emit_mad(ir_expression *ir, int mul_arg)
 281 {
 282    /* 3-src instructions were introduced in gen6. */
 283    if (brw->gen < 6)
 284       return false;
 285
 286    /* MAD can only handle floating-point data. */
 287    if (ir->type != glsl_type::float_type)
 288       return false;
 289
 290    ir_rvalue *nonmul = ir->operands[1 - mul_arg];
 291    ir_expression *mul = ir->operands[mul_arg]->as_expression();
 292
 293    if (!mul || mul->operation != ir_binop_mul)
 294       return false;
 295
 296    if (nonmul->as_constant() ||
 297        mul->operands[0]->as_constant() ||
 298        mul->operands[1]->as_constant())
 299       return false;
 300
 301    nonmul->accept(this);
 302    fs_reg src0 = this->result;
 303
 304    mul->operands[0]->accept(this);
 305    fs_reg src1 = this->result;
 306
 307    mul->operands[1]->accept(this);
 308    fs_reg src2 = this->result;
 309
 310    this->result = fs_reg(this, ir->type);
 311    emit(BRW_OPCODE_MAD, this->result, src0, src1, src2);
 312
 313    return true;
 314 }
 315
 316 void
 317 fs_visitor::visit(ir_expression *ir)
 318 {
 319    unsigned int operand;
 320    fs_reg op[3], temp;
 321    fs_inst *inst;
 322
 323    assert(ir->get_num_operands() <= 3);
 324
 325    if (try_emit_saturate(ir))
 326       return;
 327    if (ir->operation == ir_binop_add) {
 328       if (try_emit_mad(ir, 0) || try_emit_mad(ir, 1))
 329          return;
 330    }
 331
 332    for (operand = 0; operand < ir->get_num_operands(); operand++) {
 333       ir->operands[operand]->accept(this);
 334       if (this->result.file == BAD_FILE) {
 335          fail("Failed to get tree for expression operand:\n");
 336          ir->operands[operand]->print();
 337          printf("\n");
 338       }
 339       assert(this->result.is_valid_3src());
 340       op[operand] = this->result;
 341
 342       /* Matrix expression operands should have been broken down to vector
 343        * operations already.
 344        */
 345       assert(!ir->operands[operand]->type->is_matrix());
 346       /* And then those vector operands should have been broken down to scalar.
 347        */
 348       assert(!ir->operands[operand]->type->is_vector());
 349    }
 350
 351    /* Storage for our result.  If our result goes into an assignment, it will
 352     * just get copy-propagated out, so no worries.
 353     */
 354    this->result = fs_reg(this, ir->type);
 355
 356    switch (ir->operation) {
 357    case ir_unop_logic_not:
 358       /* Note that BRW_OPCODE_NOT is not appropriate here, since it is
 359        * ones complement of the whole register, not just bit 0.
 360        */
 361       emit(XOR(this->result, op[0], fs_reg(1)));
 362       break;
 363    case ir_unop_neg:
 364       op[0].negate = !op[0].negate;
 365       emit(MOV(this->result, op[0]));
 366       break;
 367    case ir_unop_abs:
 368       op[0].abs = true;
 369       op[0].negate = false;
 370       emit(MOV(this->result, op[0]));
 371       break;
 372    case ir_unop_sign:
 373       temp = fs_reg(this, ir->type);
 374
 375       emit(MOV(this->result, fs_reg(0.0f)));
 376
 377       emit(CMP(reg_null_f, op[0], fs_reg(0.0f), BRW_CONDITIONAL_G));
 378       inst = emit(MOV(this->result, fs_reg(1.0f)));
 379       inst->predicate = BRW_PREDICATE_NORMAL;
 380
 381       emit(CMP(reg_null_f, op[0], fs_reg(0.0f), BRW_CONDITIONAL_L));
 382       inst = emit(MOV(this->result, fs_reg(-1.0f)));
 383       inst->predicate = BRW_PREDICATE_NORMAL;
 384
 385       break;
 386    case ir_unop_rcp:
 387       emit_math(SHADER_OPCODE_RCP, this->result, op[0]);
 388       break;
 389
 390    case ir_unop_exp2:
 391       emit_math(SHADER_OPCODE_EXP2, this->result, op[0]);
 392       break;
 393    case ir_unop_log2:
 394       emit_math(SHADER_OPCODE_LOG2, this->result, op[0]);
 395       break;
 396    case ir_unop_exp:
 397    case ir_unop_log:
 398       assert(!"not reached: should be handled by ir_explog_to_explog2");
 399       break;
 400    case ir_unop_sin:
 401    case ir_unop_sin_reduced:
 402       emit_math(SHADER_OPCODE_SIN, this->result, op[0]);
 403       break;
 404    case ir_unop_cos:
 405    case ir_unop_cos_reduced:
 406       emit_math(SHADER_OPCODE_COS, this->result, op[0]);
 407       break;
 408
 409    case ir_unop_dFdx:
 410       emit(FS_OPCODE_DDX, this->result, op[0]);
 411       break;
 412    case ir_unop_dFdy:
 413       emit(FS_OPCODE_DDY, this->result, op[0]);
 414       break;
 415
 416    case ir_binop_add:
 417       emit(ADD(this->result, op[0], op[1]));
 418       break;
 419    case ir_binop_sub:
 420       assert(!"not reached: should be handled by ir_sub_to_add_neg");
 421       break;
 422
 423    case ir_binop_mul:
 424       if (ir->type->is_integer()) {
 425          /* For integer multiplication, the MUL uses the low 16 bits
 426           * of one of the operands (src0 on gen6, src1 on gen7).  The
 427           * MACH accumulates in the contribution of the upper 16 bits
 428           * of that operand.
 429           *
 430           * FINISHME: Emit just the MUL if we know an operand is small
 431           * enough.
 432           */
 433          if (brw->gen >= 7 && dispatch_width == 16)
 434             fail("16-wide explicit accumulator operands unsupported\n");
 435
 436          struct brw_reg acc = retype(brw_acc_reg(), this->result.type);
 437
 438          emit(MUL(acc, op[0], op[1]));
 439          emit(MACH(reg_null_d, op[0], op[1]));
 440          emit(MOV(this->result, fs_reg(acc)));
 441       } else {
 442          emit(MUL(this->result, op[0], op[1]));
 443       }
 444       break;
 445    case ir_binop_imul_high: {
 446       if (brw->gen >= 7 && dispatch_width == 16)
 447          fail("16-wide explicit accumulator operands unsupported\n");
 448
 449       struct brw_reg acc = retype(brw_acc_reg(), this->result.type);
 450
 451       emit(MUL(acc, op[0], op[1]));
 452       emit(MACH(this->result, op[0], op[1]));
 453       break;
 454    }
 455    case ir_binop_div:
 456       /* Floating point should be lowered by DIV_TO_MUL_RCP in the compiler. */
 457       assert(ir->type->is_integer());
 458       emit_math(SHADER_OPCODE_INT_QUOTIENT, this->result, op[0], op[1]);
 459       break;
 460    case ir_binop_carry: {
 461       if (brw->gen >= 7 && dispatch_width == 16)
 462          fail("16-wide explicit accumulator operands unsupported\n");
 463
 464       struct brw_reg acc = retype(brw_acc_reg(), BRW_REGISTER_TYPE_UD);
 465
 466       emit(ADDC(reg_null_ud, op[0], op[1]));
 467       emit(MOV(this->result, fs_reg(acc)));
 468       break;
 469    }
 470    case ir_binop_borrow: {
 471       if (brw->gen >= 7 && dispatch_width == 16)
 472          fail("16-wide explicit accumulator operands unsupported\n");
 473
 474       struct brw_reg acc = retype(brw_acc_reg(), BRW_REGISTER_TYPE_UD);
 475
 476       emit(SUBB(reg_null_ud, op[0], op[1]));
 477       emit(MOV(this->result, fs_reg(acc)));
 478       break;
 479    }
 480    case ir_binop_mod:
 481       /* Floating point should be lowered by MOD_TO_FRACT in the compiler. */
 482       assert(ir->type->is_integer());
 483       emit_math(SHADER_OPCODE_INT_REMAINDER, this->result, op[0], op[1]);
 484       break;
 485
 486    case ir_binop_less:
 487    case ir_binop_greater:
 488    case ir_binop_lequal:
 489    case ir_binop_gequal:
 490    case ir_binop_equal:
 491    case ir_binop_all_equal:
 492    case ir_binop_nequal:
 493    case ir_binop_any_nequal:
 494       resolve_bool_comparison(ir->operands[0], &op[0]);
 495       resolve_bool_comparison(ir->operands[1], &op[1]);
 496
 497       emit(CMP(this->result, op[0], op[1],
 498                brw_conditional_for_comparison(ir->operation)));
 499       break;
 500
 501    case ir_binop_logic_xor:
 502       emit(XOR(this->result, op[0], op[1]));
 503       break;
 504
 505    case ir_binop_logic_or:
 506       emit(OR(this->result, op[0], op[1]));
 507       break;
 508
 509    case ir_binop_logic_and:
 510       emit(AND(this->result, op[0], op[1]));
 511       break;
 512
 513    case ir_binop_dot:
 514    case ir_unop_any:
 515       assert(!"not reached: should be handled by brw_fs_channel_expressions");
 516       break;
 517
 518    case ir_unop_noise:
 519       assert(!"not reached: should be handled by lower_noise");
 520       break;
 521
 522    case ir_quadop_vector:
 523       assert(!"not reached: should be handled by lower_quadop_vector");
 524       break;
 525
 526    case ir_binop_vector_extract:
 527       assert(!"not reached: should be handled by lower_vec_index_to_cond_assign()");
 528       break;
 529
 530    case ir_triop_vector_insert:
 531       assert(!"not reached: should be handled by lower_vector_insert()");
 532       break;
 533
 534    case ir_binop_ldexp:
 535       assert(!"not reached: should be handled by ldexp_to_arith()");
 536       break;
 537
 538    case ir_unop_sqrt:
 539       emit_math(SHADER_OPCODE_SQRT, this->result, op[0]);
 540       break;
 541
 542    case ir_unop_rsq:
 543       emit_math(SHADER_OPCODE_RSQ, this->result, op[0]);
 544       break;
 545
 546    case ir_unop_bitcast_i2f:
 547    case ir_unop_bitcast_u2f:
 548       op[0].type = BRW_REGISTER_TYPE_F;
 549       this->result = op[0];
 550       break;
 551    case ir_unop_i2u:
 552    case ir_unop_bitcast_f2u:
 553       op[0].type = BRW_REGISTER_TYPE_UD;
 554       this->result = op[0];
 555       break;
 556    case ir_unop_u2i:
 557    case ir_unop_bitcast_f2i:
 558       op[0].type = BRW_REGISTER_TYPE_D;
 559       this->result = op[0];
 560       break;
 561    case ir_unop_i2f:
 562    case ir_unop_u2f:
 563    case ir_unop_f2i:
 564    case ir_unop_f2u:
 565       emit(MOV(this->result, op[0]));
 566       break;
 567
 568    case ir_unop_b2i:
 569       emit(AND(this->result, op[0], fs_reg(1)));
 570       break;
 571    case ir_unop_b2f:
 572       temp = fs_reg(this, glsl_type::int_type);
 573       emit(AND(temp, op[0], fs_reg(1)));
 574       emit(MOV(this->result, temp));
 575       break;
 576
 577    case ir_unop_f2b:
 578       emit(CMP(this->result, op[0], fs_reg(0.0f), BRW_CONDITIONAL_NZ));
 579       break;
 580    case ir_unop_i2b:
 581       emit(CMP(this->result, op[0], fs_reg(0), BRW_CONDITIONAL_NZ));
 582       break;
 583
 584    case ir_unop_trunc:
 585       emit(RNDZ(this->result, op[0]));
 586       break;
 587    case ir_unop_ceil:
 588       op[0].negate = !op[0].negate;
 589       emit(RNDD(this->result, op[0]));
 590       this->result.negate = true;
 591       break;
 592    case ir_unop_floor:
 593       emit(RNDD(this->result, op[0]));
 594       break;
 595    case ir_unop_fract:
 596       emit(FRC(this->result, op[0]));
 597       break;
 598    case ir_unop_round_even:
 599       emit(RNDE(this->result, op[0]));
 600       break;
 601
 602    case ir_binop_min:
 603    case ir_binop_max:
 604       resolve_ud_negate(&op[0]);
 605       resolve_ud_negate(&op[1]);
 606       emit_minmax(ir->operation == ir_binop_min ?
 607                   BRW_CONDITIONAL_L : BRW_CONDITIONAL_GE,
 608                   this->result, op[0], op[1]);
 609       break;
 610    case ir_unop_pack_snorm_2x16:
 611    case ir_unop_pack_snorm_4x8:
 612    case ir_unop_pack_unorm_2x16:
 613    case ir_unop_pack_unorm_4x8:
 614    case ir_unop_unpack_snorm_2x16:
 615    case ir_unop_unpack_snorm_4x8:
 616    case ir_unop_unpack_unorm_2x16:
 617    case ir_unop_unpack_unorm_4x8:
 618    case ir_unop_unpack_half_2x16:
 619    case ir_unop_pack_half_2x16:
 620       assert(!"not reached: should be handled by lower_packing_builtins");
 621       break;
 622    case ir_unop_unpack_half_2x16_split_x:
 623       emit(FS_OPCODE_UNPACK_HALF_2x16_SPLIT_X, this->result, op[0]);
 624       break;
 625    case ir_unop_unpack_half_2x16_split_y:
 626       emit(FS_OPCODE_UNPACK_HALF_2x16_SPLIT_Y, this->result, op[0]);
 627       break;
 628    case ir_binop_pow:
 629       emit_math(SHADER_OPCODE_POW, this->result, op[0], op[1]);
 630       break;
 631
 632    case ir_unop_bitfield_reverse:
 633       emit(BFREV(this->result, op[0]));
 634       break;
 635    case ir_unop_bit_count:
 636       emit(CBIT(this->result, op[0]));
 637       break;
 638    case ir_unop_find_msb:
 639       temp = fs_reg(this, glsl_type::uint_type);
 640       emit(FBH(temp, op[0]));
 641
 642       /* FBH counts from the MSB side, while GLSL's findMSB() wants the count
 643        * from the LSB side. If FBH didn't return an error (0xFFFFFFFF), then
 644        * subtract the result from 31 to convert the MSB count into an LSB count.
 645        */
 646
 647       /* FBH only supports UD type for dst, so use a MOV to convert UD to D. */
 648       emit(MOV(this->result, temp));
 649       emit(CMP(reg_null_d, this->result, fs_reg(-1), BRW_CONDITIONAL_NZ));
 650
 651       temp.negate = true;
 652       inst = emit(ADD(this->result, temp, fs_reg(31)));
 653       inst->predicate = BRW_PREDICATE_NORMAL;
 654       break;
 655    case ir_unop_find_lsb:
 656       emit(FBL(this->result, op[0]));
 657       break;
 658    case ir_triop_bitfield_extract:
 659       /* Note that the instruction's argument order is reversed from GLSL
 660        * and the IR.
 661        */
 662       emit(BFE(this->result, op[2], op[1], op[0]));
 663       break;
 664    case ir_binop_bfm:
 665       emit(BFI1(this->result, op[0], op[1]));
 666       break;
 667    case ir_triop_bfi:
 668       emit(BFI2(this->result, op[0], op[1], op[2]));
 669       break;
 670    case ir_quadop_bitfield_insert:
 671       assert(!"not reached: should be handled by "
 672               "lower_instructions::bitfield_insert_to_bfm_bfi");
 673       break;
 674
 675    case ir_unop_bit_not:
 676       emit(NOT(this->result, op[0]));
 677       break;
 678    case ir_binop_bit_and:
 679       emit(AND(this->result, op[0], op[1]));
 680       break;
 681    case ir_binop_bit_xor:
 682       emit(XOR(this->result, op[0], op[1]));
 683       break;
 684    case ir_binop_bit_or:
 685       emit(OR(this->result, op[0], op[1]));
 686       break;
 687
 688    case ir_binop_lshift:
 689       emit(SHL(this->result, op[0], op[1]));
 690       break;
 691
 692    case ir_binop_rshift:
 693       if (ir->type->base_type == GLSL_TYPE_INT)
 694          emit(ASR(this->result, op[0], op[1]));
 695       else
 696          emit(SHR(this->result, op[0], op[1]));
 697       break;
 698    case ir_binop_pack_half_2x16_split:
 699       emit(FS_OPCODE_PACK_HALF_2x16_SPLIT, this->result, op[0], op[1]);
 700       break;
 701    case ir_binop_ubo_load: {
 702       /* This IR node takes a constant uniform block and a constant or
 703        * variable byte offset within the block and loads a vector from that.
 704        */
 705       ir_constant *uniform_block = ir->operands[0]->as_constant();
 706       ir_constant *const_offset = ir->operands[1]->as_constant();
 707       fs_reg surf_index = fs_reg(c->prog_data.base.binding_table.ubo_start +
 708                                  uniform_block->value.u[0]);
 709       if (const_offset) {
 710          fs_reg packed_consts = fs_reg(this, glsl_type::float_type);
 711          packed_consts.type = result.type;
 712
 713          fs_reg const_offset_reg = fs_reg(const_offset->value.u[0] & ~15);
 714          emit(fs_inst(FS_OPCODE_UNIFORM_PULL_CONSTANT_LOAD,
 715                       packed_consts, surf_index, const_offset_reg));
 716
 717          packed_consts.smear = const_offset->value.u[0] % 16 / 4;
 718          for (int i = 0; i < ir->type->vector_elements; i++) {
 719             /* UBO bools are any nonzero value.  We consider bools to be
 720              * values with the low bit set to 1.  Convert them using CMP.
 721              */
 722             if (ir->type->base_type == GLSL_TYPE_BOOL) {
 723                emit(CMP(result, packed_consts, fs_reg(0u), BRW_CONDITIONAL_NZ));
 724             } else {
 725                emit(MOV(result, packed_consts));
 726             }
 727
 728             packed_consts.smear++;
 729             result.reg_offset++;
 730
 731             /* The std140 packing rules don't allow vectors to cross 16-byte
 732              * boundaries, and a reg is 32 bytes.
 733              */
 734             assert(packed_consts.smear < 8);
 735          }
 736       } else {
 737          /* Turn the byte offset into a dword offset. */
 738          fs_reg base_offset = fs_reg(this, glsl_type::int_type);
 739          emit(SHR(base_offset, op[1], fs_reg(2)));
 740
 741          for (int i = 0; i < ir->type->vector_elements; i++) {
 742             emit(VARYING_PULL_CONSTANT_LOAD(result, surf_index,
 743                                             base_offset, i));
 744
 745             if (ir->type->base_type == GLSL_TYPE_BOOL)
 746                emit(CMP(result, result, fs_reg(0), BRW_CONDITIONAL_NZ));
 747
 748             result.reg_offset++;
 749          }
 750       }
 751
 752       result.reg_offset = 0;
 753       break;
 754    }
 755
 756    case ir_triop_fma:
 757       /* Note that the instruction's argument order is reversed from GLSL
 758        * and the IR.
 759        */
 760       emit(MAD(this->result, op[2], op[1], op[0]));
 761       break;
 762
 763    case ir_triop_lrp:
 764       emit_lrp(this->result, op[0], op[1], op[2]);
 765       break;
 766
 767    case ir_triop_csel:
 768       emit(CMP(reg_null_d, op[0], fs_reg(0), BRW_CONDITIONAL_NZ));
 769       inst = emit(BRW_OPCODE_SEL, this->result, op[1], op[2]);
 770       inst->predicate = BRW_PREDICATE_NORMAL;
 771       break;
 772    }
 773 }
 774
 775 void
 776 fs_visitor::emit_assignment_writes(fs_reg &l, fs_reg &r,
 777                                    const glsl_type *type, bool predicated)
 778 {
 779    switch (type->base_type) {
 780    case GLSL_TYPE_FLOAT:
 781    case GLSL_TYPE_UINT:
 782    case GLSL_TYPE_INT:
 783    case GLSL_TYPE_BOOL:
 784       for (unsigned int i = 0; i < type->components(); i++) {
 785          l.type = brw_type_for_base_type(type);
 786          r.type = brw_type_for_base_type(type);
 787
 788          if (predicated || !l.equals(r)) {
 789             fs_inst *inst = emit(MOV(l, r));
 790             inst->predicate = predicated ? BRW_PREDICATE_NORMAL : BRW_PREDICATE_NONE;
 791          }
 792
 793          l.reg_offset++;
 794          r.reg_offset++;
 795       }
 796       break;
 797    case GLSL_TYPE_ARRAY:
 798       for (unsigned int i = 0; i < type->length; i++) {
 799          emit_assignment_writes(l, r, type->fields.array, predicated);
 800       }
 801       break;
 802
 803    case GLSL_TYPE_STRUCT:
 804       for (unsigned int i = 0; i < type->length; i++) {
 805          emit_assignment_writes(l, r, type->fields.structure[i].type,
 806                                 predicated);
 807       }
 808       break;
 809
 810    case GLSL_TYPE_SAMPLER:
 811    case GLSL_TYPE_ATOMIC_UINT:
 812       break;
 813
 814    case GLSL_TYPE_VOID:
 815    case GLSL_TYPE_ERROR:
 816    case GLSL_TYPE_INTERFACE:
 817       assert(!"not reached");
 818       break;
 819    }
 820 }
 821
 822 /* If the RHS processing resulted in an instruction generating a
 823  * temporary value, and it would be easy to rewrite the instruction to
 824  * generate its result right into the LHS instead, do so.  This ends
 825  * up reliably removing instructions where it can be tricky to do so
 826  * later without real UD chain information.
 827  */
 828 bool
 829 fs_visitor::try_rewrite_rhs_to_dst(ir_assignment *ir,
 830                                    fs_reg dst,
 831                                    fs_reg src,
 832                                    fs_inst *pre_rhs_inst,
 833                                    fs_inst *last_rhs_inst)
 834 {
 835    /* Only attempt if we're doing a direct assignment. */
 836    if (ir->condition ||
 837        !(ir->lhs->type->is_scalar() ||
 838         (ir->lhs->type->is_vector() &&
 839          ir->write_mask == (1 << ir->lhs->type->vector_elements) - 1)))
 840       return false;
 841
 842    /* Make sure the last instruction generated our source reg. */
 843    fs_inst *modify = get_instruction_generating_reg(pre_rhs_inst,
 844                                                     last_rhs_inst,
 845                                                     src);
 846    if (!modify)
 847       return false;
 848
 849    /* If last_rhs_inst wrote a different number of components than our LHS,
 850     * we can't safely rewrite it.
 851     */
 852    if (virtual_grf_sizes[dst.reg] != modify->regs_written)
 853       return false;
 854
 855    /* Success!  Rewrite the instruction. */
 856    modify->dst = dst;
 857
 858    return true;
 859 }
 860
 861 void
 862 fs_visitor::visit(ir_assignment *ir)
 863 {
 864    fs_reg l, r;
 865    fs_inst *inst;
 866
 867    /* FINISHME: arrays on the lhs */
 868    ir->lhs->accept(this);
 869    l = this->result;
 870
 871    fs_inst *pre_rhs_inst = (fs_inst *) this->instructions.get_tail();
 872
 873    ir->rhs->accept(this);
 874    r = this->result;
 875
 876    fs_inst *last_rhs_inst = (fs_inst *) this->instructions.get_tail();
 877
 878    assert(l.file != BAD_FILE);
 879    assert(r.file != BAD_FILE);
 880
 881    if (try_rewrite_rhs_to_dst(ir, l, r, pre_rhs_inst, last_rhs_inst))
 882       return;
 883
 884    if (ir->condition) {
 885       emit_bool_to_cond_code(ir->condition);
 886    }
 887
 888    if (ir->lhs->type->is_scalar() ||
 889        ir->lhs->type->is_vector()) {
 890       for (int i = 0; i < ir->lhs->type->vector_elements; i++) {
 891          if (ir->write_mask & (1 << i)) {
 892             inst = emit(MOV(l, r));
 893             if (ir->condition)
 894                inst->predicate = BRW_PREDICATE_NORMAL;
 895             r.reg_offset++;
 896          }
 897          l.reg_offset++;
 898       }
 899    } else {
 900       emit_assignment_writes(l, r, ir->lhs->type, ir->condition != NULL);
 901    }
 902 }
 903
 904 fs_inst *
 905 fs_visitor::emit_texture_gen4(ir_texture *ir, fs_reg dst, fs_reg coordinate,
 906                               fs_reg shadow_c, fs_reg lod, fs_reg dPdy)
 907 {
 908    int mlen;
 909    int base_mrf = 1;
 910    bool simd16 = false;
 911    fs_reg orig_dst;
 912
 913    /* g0 header. */
 914    mlen = 1;
 915
 916    if (ir->shadow_comparitor) {
 917       for (int i = 0; i < ir->coordinate->type->vector_elements; i++) {
 918          emit(MOV(fs_reg(MRF, base_mrf + mlen + i), coordinate));
 919          coordinate.reg_offset++;
 920       }
 921
 922       /* gen4's SIMD8 sampler always has the slots for u,v,r present.
 923        * the unused slots must be zeroed.
 924        */
 925       for (int i = ir->coordinate->type->vector_elements; i < 3; i++) {
 926          emit(MOV(fs_reg(MRF, base_mrf + mlen + i), fs_reg(0.0f)));
 927       }
 928       mlen += 3;
 929
 930       if (ir->op == ir_tex) {
 931          /* There's no plain shadow compare message, so we use shadow
 932           * compare with a bias of 0.0.
 933           */
 934          emit(MOV(fs_reg(MRF, base_mrf + mlen), fs_reg(0.0f)));
 935          mlen++;
 936       } else if (ir->op == ir_txb || ir->op == ir_txl) {
 937          emit(MOV(fs_reg(MRF, base_mrf + mlen), lod));
 938          mlen++;
 939       } else {
 940          assert(!"Should not get here.");
 941       }
 942
 943       emit(MOV(fs_reg(MRF, base_mrf + mlen), shadow_c));
 944       mlen++;
 945    } else if (ir->op == ir_tex) {
 946       for (int i = 0; i < ir->coordinate->type->vector_elements; i++) {
 947          emit(MOV(fs_reg(MRF, base_mrf + mlen + i), coordinate));
 948          coordinate.reg_offset++;
 949       }
 950       /* zero the others. */
 951       for (int i = ir->coordinate->type->vector_elements; i<3; i++) {
 952          emit(MOV(fs_reg(MRF, base_mrf + mlen + i), fs_reg(0.0f)));
 953       }
 954       /* gen4's SIMD8 sampler always has the slots for u,v,r present. */
 955       mlen += 3;
 956    } else if (ir->op == ir_txd) {
 957       fs_reg &dPdx = lod;
 958
 959       for (int i = 0; i < ir->coordinate->type->vector_elements; i++) {
 960          emit(MOV(fs_reg(MRF, base_mrf + mlen + i), coordinate));
 961          coordinate.reg_offset++;
 962       }
 963       /* the slots for u and v are always present, but r is optional */
 964       mlen += MAX2(ir->coordinate->type->vector_elements, 2);
 965
 966       /*  P   = u, v, r
 967        * dPdx = dudx, dvdx, drdx
 968        * dPdy = dudy, dvdy, drdy
 969        *
 970        * 1-arg: Does not exist.
 971        *
 972        * 2-arg: dudx   dvdx   dudy   dvdy
 973        *        dPdx.x dPdx.y dPdy.x dPdy.y
 974        *        m4     m5     m6     m7
 975        *
 976        * 3-arg: dudx   dvdx   drdx   dudy   dvdy   drdy
 977        *        dPdx.x dPdx.y dPdx.z dPdy.x dPdy.y dPdy.z
 978        *        m5     m6     m7     m8     m9     m10
 979        */
 980       for (int i = 0; i < ir->lod_info.grad.dPdx->type->vector_elements; i++) {
 981          emit(MOV(fs_reg(MRF, base_mrf + mlen), dPdx));
 982          dPdx.reg_offset++;
 983       }
 984       mlen += MAX2(ir->lod_info.grad.dPdx->type->vector_elements, 2);
 985
 986       for (int i = 0; i < ir->lod_info.grad.dPdy->type->vector_elements; i++) {
 987          emit(MOV(fs_reg(MRF, base_mrf + mlen), dPdy));
 988          dPdy.reg_offset++;
 989       }
 990       mlen += MAX2(ir->lod_info.grad.dPdy->type->vector_elements, 2);
 991    } else if (ir->op == ir_txs) {
 992       /* There's no SIMD8 resinfo message on Gen4.  Use SIMD16 instead. */
 993       simd16 = true;
 994       emit(MOV(fs_reg(MRF, base_mrf + mlen, BRW_REGISTER_TYPE_UD), lod));
 995       mlen += 2;
 996    } else {
 997       /* Oh joy.  gen4 doesn't have SIMD8 non-shadow-compare bias/lod
 998        * instructions.  We'll need to do SIMD16 here.
 999        */
1000       simd16 = true;
1001       assert(ir->op == ir_txb || ir->op == ir_txl || ir->op == ir_txf);
1002
1003       for (int i = 0; i < ir->coordinate->type->vector_elements; i++) {
1004          emit(MOV(fs_reg(MRF, base_mrf + mlen + i * 2, coordinate.type),
1005                   coordinate));
1006          coordinate.reg_offset++;
1007       }
1008
1009       /* Initialize the rest of u/v/r with 0.0.  Empirically, this seems to
1010        * be necessary for TXF (ld), but seems wise to do for all messages.
1011        */
1012       for (int i = ir->coordinate->type->vector_elements; i < 3; i++) {
1013          emit(MOV(fs_reg(MRF, base_mrf + mlen + i * 2), fs_reg(0.0f)));
1014       }
1015
1016       /* lod/bias appears after u/v/r. */
1017       mlen += 6;
1018
1019       emit(MOV(fs_reg(MRF, base_mrf + mlen, lod.type), lod));
1020       mlen++;
1021
1022       /* The unused upper half. */
1023       mlen++;
1024    }
1025
1026    if (simd16) {
1027       /* Now, since we're doing simd16, the return is 2 interleaved
1028        * vec4s where the odd-indexed ones are junk. We'll need to move
1029        * this weirdness around to the expected layout.
1030        */
1031       orig_dst = dst;
1032       dst = fs_reg(GRF, virtual_grf_alloc(8),
1033                    (brw->is_g4x ?
1034                     brw_type_for_base_type(ir->type) :
1035                     BRW_REGISTER_TYPE_F));
1036    }
1037
1038    fs_inst *inst = NULL;
1039    switch (ir->op) {
1040    case ir_tex:
1041       inst = emit(SHADER_OPCODE_TEX, dst);
1042       break;
1043    case ir_txb:
1044       inst = emit(FS_OPCODE_TXB, dst);
1045       break;
1046    case ir_txl:
1047       inst = emit(SHADER_OPCODE_TXL, dst);
1048       break;
1049    case ir_txd:
1050       inst = emit(SHADER_OPCODE_TXD, dst);
1051       break;
1052    case ir_txs:
1053       inst = emit(SHADER_OPCODE_TXS, dst);
1054       break;
1055    case ir_txf:
1056       inst = emit(SHADER_OPCODE_TXF, dst);
1057       break;
1058    default:
1059       fail("unrecognized texture opcode");
1060    }
1061    inst->base_mrf = base_mrf;
1062    inst->mlen = mlen;
1063    inst->header_present = true;
1064    inst->regs_written = simd16 ? 8 : 4;
1065
1066    if (simd16) {
1067       for (int i = 0; i < 4; i++) {
1068          emit(MOV(orig_dst, dst));
1069          orig_dst.reg_offset++;
1070          dst.reg_offset += 2;
1071       }
1072    }
1073
1074    return inst;
1075 }
1076
1077 /* gen5's sampler has slots for u, v, r, array index, then optional
1078  * parameters like shadow comparitor or LOD bias.  If optional
1079  * parameters aren't present, those base slots are optional and don't
1080  * need to be included in the message.
1081  *
1082  * We don't fill in the unnecessary slots regardless, which may look
1083  * surprising in the disassembly.
1084  */
1085 fs_inst *
1086 fs_visitor::emit_texture_gen5(ir_texture *ir, fs_reg dst, fs_reg coordinate,
1087                               fs_reg shadow_c, fs_reg lod, fs_reg lod2,
1088                               fs_reg sample_index)
1089 {
1090    int mlen = 0;
1091    int base_mrf = 2;
1092    int reg_width = dispatch_width / 8;
1093    bool header_present = false;
1094    const int vector_elements =
1095       ir->coordinate ? ir->coordinate->type->vector_elements : 0;
1096
1097    if (ir->offset) {
1098       /* The offsets set up by the ir_texture visitor are in the
1099        * m1 header, so we can't go headerless.
1100        */
1101       header_present = true;
1102       mlen++;
1103       base_mrf--;
1104    }
1105
1106    for (int i = 0; i < vector_elements; i++) {
1107       emit(MOV(fs_reg(MRF, base_mrf + mlen + i * reg_width, coordinate.type),
1108                coordinate));
1109       coordinate.reg_offset++;
1110    }
1111    mlen += vector_elements * reg_width;
1112
1113    if (ir->shadow_comparitor) {
1114       mlen = MAX2(mlen, header_present + 4 * reg_width);
1115
1116       emit(MOV(fs_reg(MRF, base_mrf + mlen), shadow_c));
1117       mlen += reg_width;
1118    }
1119
1120    fs_inst *inst = NULL;
1121    switch (ir->op) {
1122    case ir_tex:
1123       inst = emit(SHADER_OPCODE_TEX, dst);
1124       break;
1125    case ir_txb:
1126       mlen = MAX2(mlen, header_present + 4 * reg_width);
1127       emit(MOV(fs_reg(MRF, base_mrf + mlen), lod));
1128       mlen += reg_width;
1129
1130       inst = emit(FS_OPCODE_TXB, dst);
1131       break;
1132    case ir_txl:
1133       mlen = MAX2(mlen, header_present + 4 * reg_width);
1134       emit(MOV(fs_reg(MRF, base_mrf + mlen), lod));
1135       mlen += reg_width;
1136
1137       inst = emit(SHADER_OPCODE_TXL, dst);
1138       break;
1139    case ir_txd: {
1140       mlen = MAX2(mlen, header_present + 4 * reg_width); /* skip over 'ai' */
1141
1142       /**
1143        *  P   =  u,    v,    r
1144        * dPdx = dudx, dvdx, drdx
1145        * dPdy = dudy, dvdy, drdy
1146        *
1147        * Load up these values:
1148        * - dudx   dudy   dvdx   dvdy   drdx   drdy
1149        * - dPdx.x dPdy.x dPdx.y dPdy.y dPdx.z dPdy.z
1150        */
1151       for (int i = 0; i < ir->lod_info.grad.dPdx->type->vector_elements; i++) {
1152          emit(MOV(fs_reg(MRF, base_mrf + mlen), lod));
1153          lod.reg_offset++;
1154          mlen += reg_width;
1155
1156          emit(MOV(fs_reg(MRF, base_mrf + mlen), lod2));
1157          lod2.reg_offset++;
1158          mlen += reg_width;
1159       }
1160
1161       inst = emit(SHADER_OPCODE_TXD, dst);
1162       break;
1163    }
1164    case ir_txs:
1165       emit(MOV(fs_reg(MRF, base_mrf + mlen, BRW_REGISTER_TYPE_UD), lod));
1166       mlen += reg_width;
1167       inst = emit(SHADER_OPCODE_TXS, dst);
1168       break;
1169    case ir_query_levels:
1170       emit(MOV(fs_reg(MRF, base_mrf + mlen, BRW_REGISTER_TYPE_UD), fs_reg(0u)));
1171       mlen += reg_width;
1172       inst = emit(SHADER_OPCODE_TXS, dst);
1173       break;
1174    case ir_txf:
1175       mlen = header_present + 4 * reg_width;
1176       emit(MOV(fs_reg(MRF, base_mrf + mlen - reg_width, BRW_REGISTER_TYPE_UD), lod));
1177       inst = emit(SHADER_OPCODE_TXF, dst);
1178       break;
1179    case ir_txf_ms:
1180       mlen = header_present + 4 * reg_width;
1181
1182       /* lod */
1183       emit(MOV(fs_reg(MRF, base_mrf + mlen - reg_width, BRW_REGISTER_TYPE_UD), fs_reg(0)));
1184       /* sample index */
1185       emit(MOV(fs_reg(MRF, base_mrf + mlen, BRW_REGISTER_TYPE_UD), sample_index));
1186       mlen += reg_width;
1187       inst = emit(SHADER_OPCODE_TXF_MS, dst);
1188       break;
1189    case ir_lod:
1190       inst = emit(SHADER_OPCODE_LOD, dst);
1191       break;
1192    case ir_tg4:
1193       inst = emit(SHADER_OPCODE_TG4, dst);
1194       break;
1195    default:
1196       fail("unrecognized texture opcode");
1197       break;
1198    }
1199    inst->base_mrf = base_mrf;
1200    inst->mlen = mlen;
1201    inst->header_present = header_present;
1202    inst->regs_written = 4;
1203
1204    if (mlen > 11) {
1205       fail("Message length >11 disallowed by hardware\n");
1206    }
1207
1208    return inst;
1209 }
1210
1211 fs_inst *
1212 fs_visitor::emit_texture_gen7(ir_texture *ir, fs_reg dst, fs_reg coordinate,
1213                               fs_reg shadow_c, fs_reg lod, fs_reg lod2,
1214                               fs_reg sample_index)
1215 {
1216    int reg_width = dispatch_width / 8;
1217    bool header_present = false;
1218
1219    fs_reg payload = fs_reg(this, glsl_type::float_type);
1220    fs_reg next = payload;
1221
1222    if (ir->op == ir_tg4 || (ir->offset && ir->op != ir_txf)) {
1223       /* For general texture offsets (no txf workaround), we need a header to
1224        * put them in.  Note that for 16-wide we're making space for two actual
1225        * hardware registers here, so the emit will have to fix up for this.
1226        *
1227        * * ir4_tg4 needs to place its channel select in the header,
1228        * for interaction with ARB_texture_swizzle
1229        */
1230       header_present = true;
1231       next.reg_offset++;
1232    }
1233
1234    if (ir->shadow_comparitor) {
1235       emit(MOV(next, shadow_c));
1236       next.reg_offset++;
1237    }
1238
1239    bool has_nonconstant_offset = ir->offset && !ir->offset->as_constant();
1240    bool coordinate_done = false;
1241
1242    /* Set up the LOD info */
1243    switch (ir->op) {
1244    case ir_tex:
1245    case ir_lod:
1246       break;
1247    case ir_txb:
1248       emit(MOV(next, lod));
1249       next.reg_offset++;
1250       break;
1251    case ir_txl:
1252       emit(MOV(next, lod));
1253       next.reg_offset++;
1254       break;
1255    case ir_txd: {
1256       if (dispatch_width == 16)
1257          fail("Gen7 does not support sample_d/sample_d_c in SIMD16 mode.");
1258
1259       /* Load dPdx and the coordinate together:
1260        * [hdr], [ref], x, dPdx.x, dPdy.x, y, dPdx.y, dPdy.y, z, dPdx.z, dPdy.z
1261        */
1262       for (int i = 0; i < ir->coordinate->type->vector_elements; i++) {
1263          emit(MOV(next, coordinate));
1264          coordinate.reg_offset++;
1265          next.reg_offset++;
1266
1267          /* For cube map array, the coordinate is (u,v,r,ai) but there are
1268           * only derivatives for (u, v, r).
1269           */
1270          if (i < ir->lod_info.grad.dPdx->type->vector_elements) {
1271             emit(MOV(next, lod));
1272             lod.reg_offset++;
1273             next.reg_offset++;
1274
1275             emit(MOV(next, lod2));
1276             lod2.reg_offset++;
1277             next.reg_offset++;
1278          }
1279       }
1280
1281       coordinate_done = true;
1282       break;
1283    }
1284    case ir_txs:
1285       emit(MOV(next.retype(BRW_REGISTER_TYPE_UD), lod));
1286       next.reg_offset++;
1287       break;
1288    case ir_query_levels:
1289       emit(MOV(next.retype(BRW_REGISTER_TYPE_UD), fs_reg(0u)));
1290       next.reg_offset++;
1291       break;
1292    case ir_txf:
1293       /* Unfortunately, the parameters for LD are intermixed: u, lod, v, r. */
1294       emit(MOV(next.retype(BRW_REGISTER_TYPE_D), coordinate));
1295       coordinate.reg_offset++;
1296       next.reg_offset++;
1297
1298       emit(MOV(next.retype(BRW_REGISTER_TYPE_D), lod));
1299       next.reg_offset++;
1300
1301       for (int i = 1; i < ir->coordinate->type->vector_elements; i++) {
1302          emit(MOV(next.retype(BRW_REGISTER_TYPE_D), coordinate));
1303          coordinate.reg_offset++;
1304          next.reg_offset++;
1305       }
1306
1307       coordinate_done = true;
1308       break;
1309    case ir_txf_ms:
1310       emit(MOV(next.retype(BRW_REGISTER_TYPE_UD), sample_index));
1311       next.reg_offset++;
1312
1313       /* constant zero MCS; we arrange to never actually have a compressed
1314        * multisample surface here for now. TODO: issue ld_mcs to get this first,
1315        * if we ever support texturing from compressed multisample surfaces
1316        */
1317       emit(MOV(next.retype(BRW_REGISTER_TYPE_UD), fs_reg(0u)));
1318       next.reg_offset++;
1319
1320       /* there is no offsetting for this message; just copy in the integer
1321        * texture coordinates
1322        */
1323       for (int i = 0; i < ir->coordinate->type->vector_elements; i++) {
1324          emit(MOV(next.retype(BRW_REGISTER_TYPE_D), coordinate));
1325          coordinate.reg_offset++;
1326          next.reg_offset++;
1327       }
1328
1329       coordinate_done = true;
1330       break;
1331    case ir_tg4:
1332       if (has_nonconstant_offset) {
1333          if (ir->shadow_comparitor && dispatch_width == 16)
1334             fail("Gen7 does not support gather4_po_c in SIMD16 mode.");
1335
1336          /* More crazy intermixing */
1337          ir->offset->accept(this);
1338          fs_reg offset_value = this->result;
1339
1340          for (int i = 0; i < 2; i++) { /* u, v */
1341             emit(MOV(next, coordinate));
1342             coordinate.reg_offset++;
1343             next.reg_offset++;
1344          }
1345
1346          for (int i = 0; i < 2; i++) { /* offu, offv */
1347             emit(MOV(next.retype(BRW_REGISTER_TYPE_D), offset_value));
1348             offset_value.reg_offset++;
1349             next.reg_offset++;
1350          }
1351
1352          if (ir->coordinate->type->vector_elements == 3) { /* r if present */
1353             emit(MOV(next, coordinate));
1354             coordinate.reg_offset++;
1355             next.reg_offset++;
1356          }
1357
1358          coordinate_done = true;
1359       }
1360       break;
1361    }
1362
1363    /* Set up the coordinate (except for cases where it was done above) */
1364    if (ir->coordinate && !coordinate_done) {
1365       for (int i = 0; i < ir->coordinate->type->vector_elements; i++) {
1366          emit(MOV(next, coordinate));
1367          coordinate.reg_offset++;
1368          next.reg_offset++;
1369       }
1370    }
1371
1372    /* Generate the SEND */
1373    fs_inst *inst = NULL;
1374    switch (ir->op) {
1375    case ir_tex: inst = emit(SHADER_OPCODE_TEX, dst, payload); break;
1376    case ir_txb: inst = emit(FS_OPCODE_TXB, dst, payload); break;
1377    case ir_txl: inst = emit(SHADER_OPCODE_TXL, dst, payload); break;
1378    case ir_txd: inst = emit(SHADER_OPCODE_TXD, dst, payload); break;
1379    case ir_txf: inst = emit(SHADER_OPCODE_TXF, dst, payload); break;
1380    case ir_txf_ms: inst = emit(SHADER_OPCODE_TXF_MS, dst, payload); break;
1381    case ir_txs: inst = emit(SHADER_OPCODE_TXS, dst, payload); break;
1382    case ir_query_levels: inst = emit(SHADER_OPCODE_TXS, dst, payload); break;
1383    case ir_lod: inst = emit(SHADER_OPCODE_LOD, dst, payload); break;
1384    case ir_tg4:
1385       if (has_nonconstant_offset)
1386          inst = emit(SHADER_OPCODE_TG4_OFFSET, dst, payload);
1387       else
1388          inst = emit(SHADER_OPCODE_TG4, dst, payload);
1389       break;
1390    }
1391    inst->base_mrf = -1;
1392    if (reg_width == 2)
1393       inst->mlen = next.reg_offset * reg_width - header_present;
1394    else
1395       inst->mlen = next.reg_offset * reg_width;
1396    inst->header_present = header_present;
1397    inst->regs_written = 4;
1398
1399    virtual_grf_sizes[payload.reg] = next.reg_offset;
1400    if (inst->mlen > 11) {
1401       fail("Message length >11 disallowed by hardware\n");
1402    }
1403
1404    return inst;
1405 }
1406
1407 fs_reg
1408 fs_visitor::rescale_texcoord(ir_texture *ir, fs_reg coordinate,
1409                              bool is_rect, int sampler, int texunit)
1410 {
1411    fs_inst *inst = NULL;
1412    bool needs_gl_clamp = true;
1413    fs_reg scale_x, scale_y;
1414
1415    /* The 965 requires the EU to do the normalization of GL rectangle
1416     * texture coordinates.  We use the program parameter state
1417     * tracking to get the scaling factor.
1418     */
1419    if (is_rect &&
1420        (brw->gen < 6 ||
1421         (brw->gen >= 6 && (c->key.tex.gl_clamp_mask[0] & (1 << sampler) ||
1422                              c->key.tex.gl_clamp_mask[1] & (1 << sampler))))) {
1423       struct gl_program_parameter_list *params = prog->Parameters;
1424       int tokens[STATE_LENGTH] = {
1425          STATE_INTERNAL,
1426          STATE_TEXRECT_SCALE,
1427          texunit,
1428          0,
1429          0
1430       };
1431
1432       if (dispatch_width == 16) {
1433          fail("rectangle scale uniform setup not supported on 16-wide\n");
1434          return coordinate;
1435       }
1436
1437       scale_x = fs_reg(UNIFORM, c->prog_data.nr_params);
1438       scale_y = fs_reg(UNIFORM, c->prog_data.nr_params + 1);
1439
1440       GLuint index = _mesa_add_state_reference(params,
1441                                                (gl_state_index *)tokens);
1442       c->prog_data.param[c->prog_data.nr_params++] =
1443          &prog->Parameters->ParameterValues[index][0].f;
1444       c->prog_data.param[c->prog_data.nr_params++] =
1445          &prog->Parameters->ParameterValues[index][1].f;
1446    }
1447
1448    /* The 965 requires the EU to do the normalization of GL rectangle
1449     * texture coordinates.  We use the program parameter state
1450     * tracking to get the scaling factor.
1451     */
1452    if (brw->gen < 6 && is_rect) {
1453       fs_reg dst = fs_reg(this, ir->coordinate->type);
1454       fs_reg src = coordinate;
1455       coordinate = dst;
1456
1457       emit(MUL(dst, src, scale_x));
1458       dst.reg_offset++;
1459       src.reg_offset++;
1460       emit(MUL(dst, src, scale_y));
1461    } else if (is_rect) {
1462       /* On gen6+, the sampler handles the rectangle coordinates
1463        * natively, without needing rescaling.  But that means we have
1464        * to do GL_CLAMP clamping at the [0, width], [0, height] scale,
1465        * not [0, 1] like the default case below.
1466        */
1467       needs_gl_clamp = false;
1468
1469       for (int i = 0; i < 2; i++) {
1470          if (c->key.tex.gl_clamp_mask[i] & (1 << sampler)) {
1471             fs_reg chan = coordinate;
1472             chan.reg_offset += i;
1473
1474             inst = emit(BRW_OPCODE_SEL, chan, chan, brw_imm_f(0.0));
1475             inst->conditional_mod = BRW_CONDITIONAL_G;
1476
1477             /* Our parameter comes in as 1.0/width or 1.0/height,
1478              * because that's what people normally want for doing
1479              * texture rectangle handling.  We need width or height
1480              * for clamping, but we don't care enough to make a new
1481              * parameter type, so just invert back.
1482              */
1483             fs_reg limit = fs_reg(this, glsl_type::float_type);
1484             emit(MOV(limit, i == 0 ? scale_x : scale_y));
1485             emit(SHADER_OPCODE_RCP, limit, limit);
1486
1487             inst = emit(BRW_OPCODE_SEL, chan, chan, limit);
1488             inst->conditional_mod = BRW_CONDITIONAL_L;
1489          }
1490       }
1491    }
1492
1493    if (ir->coordinate && needs_gl_clamp) {
1494       for (unsigned int i = 0;
1495            i < MIN2(ir->coordinate->type->vector_elements, 3); i++) {
1496          if (c->key.tex.gl_clamp_mask[i] & (1 << sampler)) {
1497             fs_reg chan = coordinate;
1498             chan.reg_offset += i;
1499
1500             fs_inst *inst = emit(MOV(chan, chan));
1501             inst->saturate = true;
1502          }
1503       }
1504    }
1505    return coordinate;
1506 }
1507
1508 void
1509 fs_visitor::visit(ir_texture *ir)
1510 {
1511    fs_inst *inst = NULL;
1512
1513    int sampler =
1514       _mesa_get_sampler_uniform_value(ir->sampler, shader_prog, prog);
1515    /* FINISHME: We're failing to recompile our programs when the sampler is
1516     * updated.  This only matters for the texture rectangle scale parameters
1517     * (pre-gen6, or gen6+ with GL_CLAMP).
1518     */
1519    int texunit = prog->SamplerUnits[sampler];
1520
1521    if (ir->op == ir_tg4) {
1522       /* When tg4 is used with the degenerate ZERO/ONE swizzles, don't bother
1523        * emitting anything other than setting up the constant result.
1524        */
1525       ir_constant *chan = ir->lod_info.component->as_constant();
1526       int swiz = GET_SWZ(c->key.tex.swizzles[sampler], chan->value.i[0]);
1527       if (swiz == SWIZZLE_ZERO || swiz == SWIZZLE_ONE) {
1528
1529          fs_reg res = fs_reg(this, glsl_type::vec4_type);
1530          this->result = res;
1531
1532          for (int i=0; i<4; i++) {
1533             emit(MOV(res, fs_reg(swiz == SWIZZLE_ZERO ? 0.0f : 1.0f)));
1534             res.reg_offset++;
1535          }
1536          return;
1537       }
1538    }
1539
1540    /* Should be lowered by do_lower_texture_projection */
1541    assert(!ir->projector);
1542
1543    /* Should be lowered */
1544    assert(!ir->offset || !ir->offset->type->is_array());
1545
1546    /* Generate code to compute all the subexpression trees.  This has to be
1547     * done before loading any values into MRFs for the sampler message since
1548     * generating these values may involve SEND messages that need the MRFs.
1549     */
1550    fs_reg coordinate;
1551    if (ir->coordinate) {
1552       ir->coordinate->accept(this);
1553
1554       coordinate = rescale_texcoord(ir, this->result,
1555                                     ir->sampler->type->sampler_dimensionality ==
1556                                     GLSL_SAMPLER_DIM_RECT,
1557                                     sampler, texunit);
1558    }
1559
1560    fs_reg shadow_comparitor;
1561    if (ir->shadow_comparitor) {
1562       ir->shadow_comparitor->accept(this);
1563       shadow_comparitor = this->result;
1564    }
1565
1566    fs_reg lod, lod2, sample_index;
1567    switch (ir->op) {
1568    case ir_tex:
1569    case ir_lod:
1570    case ir_tg4:
1571    case ir_query_levels:
1572       break;
1573    case ir_txb:
1574       ir->lod_info.bias->accept(this);
1575       lod = this->result;
1576       break;
1577    case ir_txd:
1578       ir->lod_info.grad.dPdx->accept(this);
1579       lod = this->result;
1580
1581       ir->lod_info.grad.dPdy->accept(this);
1582       lod2 = this->result;
1583       break;
1584    case ir_txf:
1585    case ir_txl:
1586    case ir_txs:
1587       ir->lod_info.lod->accept(this);
1588       lod = this->result;
1589       break;
1590    case ir_txf_ms:
1591       ir->lod_info.sample_index->accept(this);
1592       sample_index = this->result;
1593       break;
1594    default:
1595       assert(!"Unrecognized texture opcode");
1596    };
1597
1598    /* Writemasking doesn't eliminate channels on SIMD8 texture
1599     * samples, so don't worry about them.
1600     */
1601    fs_reg dst = fs_reg(this, glsl_type::get_instance(ir->type->base_type, 4, 1));
1602
1603    if (brw->gen >= 7) {
1604       inst = emit_texture_gen7(ir, dst, coordinate, shadow_comparitor,
1605                                lod, lod2, sample_index);
1606    } else if (brw->gen >= 5) {
1607       inst = emit_texture_gen5(ir, dst, coordinate, shadow_comparitor,
1608                                lod, lod2, sample_index);
1609    } else {
1610       inst = emit_texture_gen4(ir, dst, coordinate, shadow_comparitor,
1611                                lod, lod2);
1612    }
1613
1614    if (ir->offset != NULL && ir->op != ir_txf)
1615       inst->texture_offset = brw_texture_offset(ctx, ir->offset->as_constant());
1616
1617    if (ir->op == ir_tg4)
1618       inst->texture_offset |= gather_channel(ir, sampler) << 16; // M0.2:16-17
1619
1620    inst->sampler = sampler;
1621
1622    if (ir->shadow_comparitor)
1623       inst->shadow_compare = true;
1624
1625    /* fixup #layers for cube map arrays */
1626    if (ir->op == ir_txs) {
1627       glsl_type const *type = ir->sampler->type;
1628       if (type->sampler_dimensionality == GLSL_SAMPLER_DIM_CUBE &&
1629           type->sampler_array) {
1630          fs_reg depth = dst;
1631          depth.reg_offset = 2;
1632          emit_math(SHADER_OPCODE_INT_QUOTIENT, depth, depth, fs_reg(6));
1633       }
1634    }
1635
1636    swizzle_result(ir, dst, sampler);
1637 }
1638
1639 /**
1640  * Set up the gather channel based on the swizzle, for gather4.
1641  */
1642 uint32_t
1643 fs_visitor::gather_channel(ir_texture *ir, int sampler)
1644 {
1645    ir_constant *chan = ir->lod_info.component->as_constant();
1646    int swiz = GET_SWZ(c->key.tex.swizzles[sampler], chan->value.i[0]);
1647    switch (swiz) {
1648       case SWIZZLE_X: return 0;
1649       case SWIZZLE_Y:
1650          /* gather4 sampler is broken for green channel on RG32F --
1651           * we must ask for blue instead.
1652           */
1653          if (c->key.tex.gather_channel_quirk_mask & (1<<sampler))
1654             return 2;
1655          return 1;
1656       case SWIZZLE_Z: return 2;
1657       case SWIZZLE_W: return 3;
1658       default:
1659          assert(!"Not reached"); /* zero, one swizzles handled already */
1660          return 0;
1661    }
1662 }
1663
1664 /**
1665  * Swizzle the result of a texture result.  This is necessary for
1666  * EXT_texture_swizzle as well as DEPTH_TEXTURE_MODE for shadow comparisons.
1667  */
1668 void
1669 fs_visitor::swizzle_result(ir_texture *ir, fs_reg orig_val, int sampler)
1670 {
1671    if (ir->op == ir_query_levels) {
1672       /* # levels is in .w */
1673       orig_val.reg_offset += 3;
1674       this->result = orig_val;
1675       return;
1676    }
1677
1678    this->result = orig_val;
1679
1680    /* txs,lod don't actually sample the texture, so swizzling the result
1681     * makes no sense.
1682     */
1683    if (ir->op == ir_txs || ir->op == ir_lod || ir->op == ir_tg4)
1684       return;
1685
1686    if (ir->type == glsl_type::float_type) {
1687       /* Ignore DEPTH_TEXTURE_MODE swizzling. */
1688       assert(ir->sampler->type->sampler_shadow);
1689    } else if (c->key.tex.swizzles[sampler] != SWIZZLE_NOOP) {
1690       fs_reg swizzled_result = fs_reg(this, glsl_type::vec4_type);
1691
1692       for (int i = 0; i < 4; i++) {
1693          int swiz = GET_SWZ(c->key.tex.swizzles[sampler], i);
1694          fs_reg l = swizzled_result;
1695          l.reg_offset += i;
1696
1697          if (swiz == SWIZZLE_ZERO) {
1698             emit(MOV(l, fs_reg(0.0f)));
1699          } else if (swiz == SWIZZLE_ONE) {
1700             emit(MOV(l, fs_reg(1.0f)));
1701          } else {
1702             fs_reg r = orig_val;
1703             r.reg_offset += GET_SWZ(c->key.tex.swizzles[sampler], i);
1704             emit(MOV(l, r));
1705          }
1706       }
1707       this->result = swizzled_result;
1708    }
1709 }
1710
1711 void
1712 fs_visitor::visit(ir_swizzle *ir)
1713 {
1714    ir->val->accept(this);
1715    fs_reg val = this->result;
1716
1717    if (ir->type->vector_elements == 1) {
1718       this->result.reg_offset += ir->mask.x;
1719       return;
1720    }
1721
1722    fs_reg result = fs_reg(this, ir->type);
1723    this->result = result;
1724
1725    for (unsigned int i = 0; i < ir->type->vector_elements; i++) {
1726       fs_reg channel = val;
1727       int swiz = 0;
1728
1729       switch (i) {
1730       case 0:
1731          swiz = ir->mask.x;
1732          break;
1733       case 1:
1734          swiz = ir->mask.y;
1735          break;
1736       case 2:
1737          swiz = ir->mask.z;
1738          break;
1739       case 3:
1740          swiz = ir->mask.w;
1741          break;
1742       }
1743
1744       channel.reg_offset += swiz;
1745       emit(MOV(result, channel));
1746       result.reg_offset++;
1747    }
1748 }
1749
1750 void
1751 fs_visitor::visit(ir_discard *ir)
1752 {
1753    assert(ir->condition == NULL); /* FINISHME */
1754
1755    /* We track our discarded pixels in f0.1.  By predicating on it, we can
1756     * update just the flag bits that aren't yet discarded.  By emitting a
1757     * CMP of g0 != g0, all our currently executing channels will get turned
1758     * off.
1759     */
1760    fs_reg some_reg = fs_reg(retype(brw_vec8_grf(0, 0),
1761                                    BRW_REGISTER_TYPE_UW));
1762    fs_inst *cmp = emit(CMP(reg_null_f, some_reg, some_reg,
1763                            BRW_CONDITIONAL_NZ));
1764    cmp->predicate = BRW_PREDICATE_NORMAL;
1765    cmp->flag_subreg = 1;
1766
1767    if (brw->gen >= 6) {
1768       /* For performance, after a discard, jump to the end of the shader.
1769        * However, many people will do foliage by discarding based on a
1770        * texture's alpha mask, and then continue on to texture with the
1771        * remaining pixels.  To avoid trashing the derivatives for those
1772        * texture samples, we'll only jump if all of the pixels in the subspan
1773        * have been discarded.
1774        */
1775       fs_inst *discard_jump = emit(FS_OPCODE_DISCARD_JUMP);
1776       discard_jump->flag_subreg = 1;
1777       discard_jump->predicate = BRW_PREDICATE_ALIGN1_ANY4H;
1778       discard_jump->predicate_inverse = true;
1779    }
1780 }
1781
1782 void
1783 fs_visitor::visit(ir_constant *ir)
1784 {
1785    /* Set this->result to reg at the bottom of the function because some code
1786     * paths will cause this visitor to be applied to other fields.  This will
1787     * cause the value stored in this->result to be modified.
1788     *
1789     * Make reg constant so that it doesn't get accidentally modified along the
1790     * way.  Yes, I actually had this problem. :(
1791     */
1792    const fs_reg reg(this, ir->type);
1793    fs_reg dst_reg = reg;
1794
1795    if (ir->type->is_array()) {
1796       const unsigned size = type_size(ir->type->fields.array);
1797
1798       for (unsigned i = 0; i < ir->type->length; i++) {
1799          ir->array_elements[i]->accept(this);
1800          fs_reg src_reg = this->result;
1801
1802          dst_reg.type = src_reg.type;
1803          for (unsigned j = 0; j < size; j++) {
1804             emit(MOV(dst_reg, src_reg));
1805             src_reg.reg_offset++;
1806             dst_reg.reg_offset++;
1807          }
1808       }
1809    } else if (ir->type->is_record()) {
1810       foreach_list(node, &ir->components) {
1811          ir_constant *const field = (ir_constant *) node;
1812          const unsigned size = type_size(field->type);
1813
1814          field->accept(this);
1815          fs_reg src_reg = this->result;
1816
1817          dst_reg.type = src_reg.type;
1818          for (unsigned j = 0; j < size; j++) {
1819             emit(MOV(dst_reg, src_reg));
1820             src_reg.reg_offset++;
1821             dst_reg.reg_offset++;
1822          }
1823       }
1824    } else {
1825       const unsigned size = type_size(ir->type);
1826
1827       for (unsigned i = 0; i < size; i++) {
1828          switch (ir->type->base_type) {
1829          case GLSL_TYPE_FLOAT:
1830             emit(MOV(dst_reg, fs_reg(ir->value.f[i])));
1831             break;
1832          case GLSL_TYPE_UINT:
1833             emit(MOV(dst_reg, fs_reg(ir->value.u[i])));
1834             break;
1835          case GLSL_TYPE_INT:
1836             emit(MOV(dst_reg, fs_reg(ir->value.i[i])));
1837             break;
1838          case GLSL_TYPE_BOOL:
1839             emit(MOV(dst_reg, fs_reg((int)ir->value.b[i])));
1840             break;
1841          default:
1842             assert(!"Non-float/uint/int/bool constant");
1843          }
1844          dst_reg.reg_offset++;
1845       }
1846    }
1847
1848    this->result = reg;
1849 }
1850
1851 void
1852 fs_visitor::emit_bool_to_cond_code(ir_rvalue *ir)
1853 {
1854    ir_expression *expr = ir->as_expression();
1855
1856    if (expr &&
1857        expr->operation != ir_binop_logic_and &&
1858        expr->operation != ir_binop_logic_or &&
1859        expr->operation != ir_binop_logic_xor) {
1860       fs_reg op[2];
1861       fs_inst *inst;
1862
1863       assert(expr->get_num_operands() <= 2);
1864       for (unsigned int i = 0; i < expr->get_num_operands(); i++) {
1865          assert(expr->operands[i]->type->is_scalar());
1866
1867          expr->operands[i]->accept(this);
1868          op[i] = this->result;
1869
1870          resolve_ud_negate(&op[i]);
1871       }
1872
1873       switch (expr->operation) {
1874       case ir_unop_logic_not:
1875          inst = emit(AND(reg_null_d, op[0], fs_reg(1)));
1876          inst->conditional_mod = BRW_CONDITIONAL_Z;
1877          break;
1878
1879       case ir_unop_f2b:
1880          if (brw->gen >= 6) {
1881             emit(CMP(reg_null_d, op[0], fs_reg(0.0f), BRW_CONDITIONAL_NZ));
1882          } else {
1883             inst = emit(MOV(reg_null_f, op[0]));
1884             inst->conditional_mod = BRW_CONDITIONAL_NZ;
1885          }
1886          break;
1887
1888       case ir_unop_i2b:
1889          if (brw->gen >= 6) {
1890             emit(CMP(reg_null_d, op[0], fs_reg(0), BRW_CONDITIONAL_NZ));
1891          } else {
1892             inst = emit(MOV(reg_null_d, op[0]));
1893             inst->conditional_mod = BRW_CONDITIONAL_NZ;
1894          }
1895          break;
1896
1897       case ir_binop_greater:
1898       case ir_binop_gequal:
1899       case ir_binop_less:
1900       case ir_binop_lequal:
1901       case ir_binop_equal:
1902       case ir_binop_all_equal:
1903       case ir_binop_nequal:
1904       case ir_binop_any_nequal:
1905          resolve_bool_comparison(expr->operands[0], &op[0]);
1906          resolve_bool_comparison(expr->operands[1], &op[1]);
1907
1908          emit(CMP(reg_null_d, op[0], op[1],
1909                   brw_conditional_for_comparison(expr->operation)));
1910          break;
1911
1912       default:
1913          assert(!"not reached");
1914          fail("bad cond code\n");
1915          break;
1916       }
1917       return;
1918    }
1919
1920    ir->accept(this);
1921
1922    fs_inst *inst = emit(AND(reg_null_d, this->result, fs_reg(1)));
1923    inst->conditional_mod = BRW_CONDITIONAL_NZ;
1924 }
1925
1926 /**
1927  * Emit a gen6 IF statement with the comparison folded into the IF
1928  * instruction.
1929  */
1930 void
1931 fs_visitor::emit_if_gen6(ir_if *ir)
1932 {
1933    ir_expression *expr = ir->condition->as_expression();
1934
1935    if (expr) {
1936       fs_reg op[2];
1937       fs_inst *inst;
1938       fs_reg temp;
1939
1940       assert(expr->get_num_operands() <= 2);
1941       for (unsigned int i = 0; i < expr->get_num_operands(); i++) {
1942          assert(expr->operands[i]->type->is_scalar());
1943
1944          expr->operands[i]->accept(this);
1945          op[i] = this->result;
1946       }
1947
1948       switch (expr->operation) {
1949       case ir_unop_logic_not:
1950       case ir_binop_logic_xor:
1951       case ir_binop_logic_or:
1952       case ir_binop_logic_and:
1953          /* For operations on bool arguments, only the low bit of the bool is
1954           * valid, and the others are undefined.  Fall back to the condition
1955           * code path.
1956           */
1957          break;
1958
1959       case ir_unop_f2b:
1960          inst = emit(BRW_OPCODE_IF, reg_null_f, op[0], fs_reg(0));
1961          inst->conditional_mod = BRW_CONDITIONAL_NZ;
1962          return;
1963
1964       case ir_unop_i2b:
1965          emit(IF(op[0], fs_reg(0), BRW_CONDITIONAL_NZ));
1966          return;
1967
1968       case ir_binop_greater:
1969       case ir_binop_gequal:
1970       case ir_binop_less:
1971       case ir_binop_lequal:
1972       case ir_binop_equal:
1973       case ir_binop_all_equal:
1974       case ir_binop_nequal:
1975       case ir_binop_any_nequal:
1976          resolve_bool_comparison(expr->operands[0], &op[0]);
1977          resolve_bool_comparison(expr->operands[1], &op[1]);
1978
1979          emit(IF(op[0], op[1],
1980                  brw_conditional_for_comparison(expr->operation)));
1981          return;
1982       default:
1983          assert(!"not reached");
1984          emit(IF(op[0], fs_reg(0), BRW_CONDITIONAL_NZ));
1985          fail("bad condition\n");
1986          return;
1987       }
1988    }
1989
1990    emit_bool_to_cond_code(ir->condition);
1991    fs_inst *inst = emit(BRW_OPCODE_IF);
1992    inst->predicate = BRW_PREDICATE_NORMAL;
1993 }
1994
1995 /**
1996  * Try to replace IF/MOV/ELSE/MOV/ENDIF with SEL.
1997  *
1998  * Many GLSL shaders contain the following pattern:
1999  *
2000  *    x = condition ? foo : bar
2001  *
2002  * The compiler emits an ir_if tree for this, since each subexpression might be
2003  * a complex tree that could have side-effects or short-circuit logic.
2004  *
2005  * However, the common case is to simply select one of two constants or
2006  * variable values---which is exactly what SEL is for.  In this case, the
2007  * assembly looks like:
2008  *
2009  *    (+f0) IF
2010  *    MOV dst src0
2011  *    ELSE
2012  *    MOV dst src1
2013  *    ENDIF
2014  *
2015  * which can be easily translated into:
2016  *
2017  *    (+f0) SEL dst src0 src1
2018  *
2019  * If src0 is an immediate value, we promote it to a temporary GRF.
2020  */
2021 void
2022 fs_visitor::try_replace_with_sel()
2023 {
2024    fs_inst *endif_inst = (fs_inst *) instructions.get_tail();
2025    assert(endif_inst->opcode == BRW_OPCODE_ENDIF);
2026
2027    /* Pattern match in reverse: IF, MOV, ELSE, MOV, ENDIF. */
2028    int opcodes[] = {
2029       BRW_OPCODE_IF, BRW_OPCODE_MOV, BRW_OPCODE_ELSE, BRW_OPCODE_MOV,
2030    };
2031
2032    fs_inst *match = (fs_inst *) endif_inst->prev;
2033    for (int i = 0; i < 4; i++) {
2034       if (match->is_head_sentinel() || match->opcode != opcodes[4-i-1])
2035          return;
2036       match = (fs_inst *) match->prev;
2037    }
2038
2039    /* The opcodes match; it looks like the right sequence of instructions. */
2040    fs_inst *else_mov = (fs_inst *) endif_inst->prev;
2041    fs_inst *then_mov = (fs_inst *) else_mov->prev->prev;
2042    fs_inst *if_inst = (fs_inst *) then_mov->prev;
2043
2044    /* Check that the MOVs are the right form. */
2045    if (then_mov->dst.equals(else_mov->dst) &&
2046        !then_mov->is_partial_write() &&
2047        !else_mov->is_partial_write()) {
2048
2049       /* Remove the matched instructions; we'll emit a SEL to replace them. */
2050       while (!if_inst->next->is_tail_sentinel())
2051          if_inst->next->remove();
2052       if_inst->remove();
2053
2054       /* Only the last source register can be a constant, so if the MOV in
2055        * the "then" clause uses a constant, we need to put it in a temporary.
2056        */
2057       fs_reg src0(then_mov->src[0]);
2058       if (src0.file == IMM) {
2059          src0 = fs_reg(this, glsl_type::float_type);
2060          src0.type = then_mov->src[0].type;
2061          emit(MOV(src0, then_mov->src[0]));
2062       }
2063
2064       fs_inst *sel;
2065       if (if_inst->conditional_mod) {
2066          /* Sandybridge-specific IF with embedded comparison */
2067          emit(CMP(reg_null_d, if_inst->src[0], if_inst->src[1],
2068                   if_inst->conditional_mod));
2069          sel = emit(BRW_OPCODE_SEL, then_mov->dst, src0, else_mov->src[0]);
2070          sel->predicate = BRW_PREDICATE_NORMAL;
2071       } else {
2072          /* Separate CMP and IF instructions */
2073          sel = emit(BRW_OPCODE_SEL, then_mov->dst, src0, else_mov->src[0]);
2074          sel->predicate = if_inst->predicate;
2075          sel->predicate_inverse = if_inst->predicate_inverse;
2076       }
2077    }
2078 }
2079
2080 void
2081 fs_visitor::visit(ir_if *ir)
2082 {
2083    if (brw->gen < 6 && dispatch_width == 16) {
2084       fail("Can't support (non-uniform) control flow on 16-wide\n");
2085    }
2086
2087    /* Don't point the annotation at the if statement, because then it plus
2088     * the then and else blocks get printed.
2089     */
2090    this->base_ir = ir->condition;
2091
2092    if (brw->gen == 6) {
2093       emit_if_gen6(ir);
2094    } else {
2095       emit_bool_to_cond_code(ir->condition);
2096
2097       emit(IF(BRW_PREDICATE_NORMAL));
2098    }
2099
2100    foreach_list(node, &ir->then_instructions) {
2101       ir_instruction *ir = (ir_instruction *)node;
2102       this->base_ir = ir;
2103
2104       ir->accept(this);
2105    }
2106
2107    if (!ir->else_instructions.is_empty()) {
2108       emit(BRW_OPCODE_ELSE);
2109
2110       foreach_list(node, &ir->else_instructions) {
2111          ir_instruction *ir = (ir_instruction *)node;
2112          this->base_ir = ir;
2113
2114          ir->accept(this);
2115       }
2116    }
2117
2118    emit(BRW_OPCODE_ENDIF);
2119
2120    try_replace_with_sel();
2121 }
2122
2123 void
2124 fs_visitor::visit(ir_loop *ir)
2125 {
2126    fs_reg counter = reg_undef;
2127
2128    if (brw->gen < 6 && dispatch_width == 16) {
2129       fail("Can't support (non-uniform) control flow on 16-wide\n");
2130    }
2131
2132    if (ir->counter) {
2133       this->base_ir = ir->counter;
2134       ir->counter->accept(this);
2135       counter = *(variable_storage(ir->counter));
2136
2137       if (ir->from) {
2138          this->base_ir = ir->from;
2139          ir->from->accept(this);
2140
2141          emit(MOV(counter, this->result));
2142       }
2143    }
2144
2145    this->base_ir = NULL;
2146    emit(BRW_OPCODE_DO);
2147
2148    if (ir->to) {
2149       this->base_ir = ir->to;
2150       ir->to->accept(this);
2151
2152       emit(CMP(reg_null_d, counter, this->result,
2153                brw_conditional_for_comparison(ir->cmp)));
2154
2155       fs_inst *inst = emit(BRW_OPCODE_BREAK);
2156       inst->predicate = BRW_PREDICATE_NORMAL;
2157    }
2158
2159    foreach_list(node, &ir->body_instructions) {
2160       ir_instruction *ir = (ir_instruction *)node;
2161
2162       this->base_ir = ir;
2163       ir->accept(this);
2164    }
2165
2166    if (ir->increment) {
2167       this->base_ir = ir->increment;
2168       ir->increment->accept(this);
2169       emit(ADD(counter, counter, this->result));
2170    }
2171
2172    this->base_ir = NULL;
2173    emit(BRW_OPCODE_WHILE);
2174 }
2175
2176 void
2177 fs_visitor::visit(ir_loop_jump *ir)
2178 {
2179    switch (ir->mode) {
2180    case ir_loop_jump::jump_break:
2181       emit(BRW_OPCODE_BREAK);
2182       break;
2183    case ir_loop_jump::jump_continue:
2184       emit(BRW_OPCODE_CONTINUE);
2185       break;
2186    }
2187 }
2188
2189 void
2190 fs_visitor::visit(ir_call *ir)
2191 {
2192    assert(!"FINISHME");
2193 }
2194
2195 void
2196 fs_visitor::visit(ir_return *ir)
2197 {
2198    assert(!"FINISHME");
2199 }
2200
2201 void
2202 fs_visitor::visit(ir_function *ir)
2203 {
2204    /* Ignore function bodies other than main() -- we shouldn't see calls to
2205     * them since they should all be inlined before we get to ir_to_mesa.
2206     */
2207    if (strcmp(ir->name, "main") == 0) {
2208       const ir_function_signature *sig;
2209       exec_list empty;
2210
2211       sig = ir->matching_signature(NULL, &empty);
2212
2213       assert(sig);
2214
2215       foreach_list(node, &sig->body) {
2216          ir_instruction *ir = (ir_instruction *)node;
2217          this->base_ir = ir;
2218
2219          ir->accept(this);
2220       }
2221    }
2222 }
2223
2224 void
2225 fs_visitor::visit(ir_function_signature *ir)
2226 {
2227    assert(!"not reached");
2228    (void)ir;
2229 }
2230
2231 void
2232 fs_visitor::visit(ir_emit_vertex *)
2233 {
2234    assert(!"not reached");
2235 }
2236
2237 void
2238 fs_visitor::visit(ir_end_primitive *)
2239 {
2240    assert(!"not reached");
2241 }
2242
2243 fs_inst *
2244 fs_visitor::emit(fs_inst inst)
2245 {
2246    fs_inst *list_inst = new(mem_ctx) fs_inst;
2247    *list_inst = inst;
2248    emit(list_inst);
2249    return list_inst;
2250 }
2251
2252 fs_inst *
2253 fs_visitor::emit(fs_inst *inst)
2254 {
2255    if (force_uncompressed_stack > 0)
2256       inst->force_uncompressed = true;
2257    else if (force_sechalf_stack > 0)
2258       inst->force_sechalf = true;
2259
2260    inst->annotation = this->current_annotation;
2261    inst->ir = this->base_ir;
2262
2263    this->instructions.push_tail(inst);
2264
2265    return inst;
2266 }
2267
2268 void
2269 fs_visitor::emit(exec_list list)
2270 {
2271    foreach_list_safe(node, &list) {
2272       fs_inst *inst = (fs_inst *)node;
2273       inst->remove();
2274       emit(inst);
2275    }
2276 }
2277
2278 /** Emits a dummy fragment shader consisting of magenta for bringup purposes. */
2279 void
2280 fs_visitor::emit_dummy_fs()
2281 {
2282    int reg_width = dispatch_width / 8;
2283
2284    /* Everyone's favorite color. */
2285    emit(MOV(fs_reg(MRF, 2 + 0 * reg_width), fs_reg(1.0f)));
2286    emit(MOV(fs_reg(MRF, 2 + 1 * reg_width), fs_reg(0.0f)));
2287    emit(MOV(fs_reg(MRF, 2 + 2 * reg_width), fs_reg(1.0f)));
2288    emit(MOV(fs_reg(MRF, 2 + 3 * reg_width), fs_reg(0.0f)));
2289
2290    fs_inst *write;
2291    write = emit(FS_OPCODE_FB_WRITE, fs_reg(0), fs_reg(0));
2292    write->base_mrf = 2;
2293    write->mlen = 4 * reg_width;
2294    write->eot = true;
2295 }
2296
2297 /* The register location here is relative to the start of the URB
2298  * data.  It will get adjusted to be a real location before
2299  * generate_code() time.
2300  */
2301 struct brw_reg
2302 fs_visitor::interp_reg(int location, int channel)
2303 {
2304    int regnr = c->prog_data.urb_setup[location] * 2 + channel / 2;
2305    int stride = (channel & 1) * 4;
2306
2307    assert(c->prog_data.urb_setup[location] != -1);
2308
2309    return brw_vec1_grf(regnr, stride);
2310 }
2311
2312 /** Emits the interpolation for the varying inputs. */
2313 void
2314 fs_visitor::emit_interpolation_setup_gen4()
2315 {
2316    this->current_annotation = "compute pixel centers";
2317    this->pixel_x = fs_reg(this, glsl_type::uint_type);
2318    this->pixel_y = fs_reg(this, glsl_type::uint_type);
2319    this->pixel_x.type = BRW_REGISTER_TYPE_UW;
2320    this->pixel_y.type = BRW_REGISTER_TYPE_UW;
2321
2322    emit(FS_OPCODE_PIXEL_X, this->pixel_x);
2323    emit(FS_OPCODE_PIXEL_Y, this->pixel_y);
2324
2325    this->current_annotation = "compute pixel deltas from v0";
2326    if (brw->has_pln) {
2327       this->delta_x[BRW_WM_PERSPECTIVE_PIXEL_BARYCENTRIC] =
2328          fs_reg(this, glsl_type::vec2_type);
2329       this->delta_y[BRW_WM_PERSPECTIVE_PIXEL_BARYCENTRIC] =
2330          this->delta_x[BRW_WM_PERSPECTIVE_PIXEL_BARYCENTRIC];
2331       this->delta_y[BRW_WM_PERSPECTIVE_PIXEL_BARYCENTRIC].reg_offset++;
2332    } else {
2333       this->delta_x[BRW_WM_PERSPECTIVE_PIXEL_BARYCENTRIC] =
2334          fs_reg(this, glsl_type::float_type);
2335       this->delta_y[BRW_WM_PERSPECTIVE_PIXEL_BARYCENTRIC] =
2336          fs_reg(this, glsl_type::float_type);
2337    }
2338    emit(ADD(this->delta_x[BRW_WM_PERSPECTIVE_PIXEL_BARYCENTRIC],
2339             this->pixel_x, fs_reg(negate(brw_vec1_grf(1, 0)))));
2340    emit(ADD(this->delta_y[BRW_WM_PERSPECTIVE_PIXEL_BARYCENTRIC],
2341             this->pixel_y, fs_reg(negate(brw_vec1_grf(1, 1)))));
2342
2343    this->current_annotation = "compute pos.w and 1/pos.w";
2344    /* Compute wpos.w.  It's always in our setup, since it's needed to
2345     * interpolate the other attributes.
2346     */
2347    this->wpos_w = fs_reg(this, glsl_type::float_type);
2348    emit(FS_OPCODE_LINTERP, wpos_w,
2349         this->delta_x[BRW_WM_PERSPECTIVE_PIXEL_BARYCENTRIC],
2350         this->delta_y[BRW_WM_PERSPECTIVE_PIXEL_BARYCENTRIC],
2351         interp_reg(VARYING_SLOT_POS, 3));
2352    /* Compute the pixel 1/W value from wpos.w. */
2353    this->pixel_w = fs_reg(this, glsl_type::float_type);
2354    emit_math(SHADER_OPCODE_RCP, this->pixel_w, wpos_w);
2355    this->current_annotation = NULL;
2356 }
2357
2358 /** Emits the interpolation for the varying inputs. */
2359 void
2360 fs_visitor::emit_interpolation_setup_gen6()
2361 {
2362    struct brw_reg g1_uw = retype(brw_vec1_grf(1, 0), BRW_REGISTER_TYPE_UW);
2363
2364    /* If the pixel centers end up used, the setup is the same as for gen4. */
2365    this->current_annotation = "compute pixel centers";
2366    fs_reg int_pixel_x = fs_reg(this, glsl_type::uint_type);
2367    fs_reg int_pixel_y = fs_reg(this, glsl_type::uint_type);
2368    int_pixel_x.type = BRW_REGISTER_TYPE_UW;
2369    int_pixel_y.type = BRW_REGISTER_TYPE_UW;
2370    emit(ADD(int_pixel_x,
2371             fs_reg(stride(suboffset(g1_uw, 4), 2, 4, 0)),
2372             fs_reg(brw_imm_v(0x10101010))));
2373    emit(ADD(int_pixel_y,
2374             fs_reg(stride(suboffset(g1_uw, 5), 2, 4, 0)),
2375             fs_reg(brw_imm_v(0x11001100))));
2376
2377    /* As of gen6, we can no longer mix float and int sources.  We have
2378     * to turn the integer pixel centers into floats for their actual
2379     * use.
2380     */
2381    this->pixel_x = fs_reg(this, glsl_type::float_type);
2382    this->pixel_y = fs_reg(this, glsl_type::float_type);
2383    emit(MOV(this->pixel_x, int_pixel_x));
2384    emit(MOV(this->pixel_y, int_pixel_y));
2385
2386    this->current_annotation = "compute pos.w";
2387    this->pixel_w = fs_reg(brw_vec8_grf(c->source_w_reg, 0));
2388    this->wpos_w = fs_reg(this, glsl_type::float_type);
2389    emit_math(SHADER_OPCODE_RCP, this->wpos_w, this->pixel_w);
2390
2391    for (int i = 0; i < BRW_WM_BARYCENTRIC_INTERP_MODE_COUNT; ++i) {
2392       uint8_t reg = c->barycentric_coord_reg[i];
2393       this->delta_x[i] = fs_reg(brw_vec8_grf(reg, 0));
2394       this->delta_y[i] = fs_reg(brw_vec8_grf(reg + 1, 0));
2395    }
2396
2397    this->current_annotation = NULL;
2398 }
2399
2400 void
2401 fs_visitor::emit_color_write(int target, int index, int first_color_mrf)
2402 {
2403    int reg_width = dispatch_width / 8;
2404    fs_inst *inst;
2405    fs_reg color = outputs[target];
2406    fs_reg mrf;
2407
2408    /* If there's no color data to be written, skip it. */
2409    if (color.file == BAD_FILE)
2410       return;
2411
2412    color.reg_offset += index;
2413
2414    if (dispatch_width == 8 || brw->gen >= 6) {
2415       /* SIMD8 write looks like:
2416        * m + 0: r0
2417        * m + 1: r1
2418        * m + 2: g0
2419        * m + 3: g1
2420        *
2421        * gen6 SIMD16 DP write looks like:
2422        * m + 0: r0
2423        * m + 1: r1
2424        * m + 2: g0
2425        * m + 3: g1
2426        * m + 4: b0
2427        * m + 5: b1
2428        * m + 6: a0
2429        * m + 7: a1
2430        */
2431       inst = emit(MOV(fs_reg(MRF, first_color_mrf + index * reg_width,
2432                              color.type),
2433                       color));
2434       inst->saturate = c->key.clamp_fragment_color;
2435    } else {
2436       /* pre-gen6 SIMD16 single source DP write looks like:
2437        * m + 0: r0
2438        * m + 1: g0
2439        * m + 2: b0
2440        * m + 3: a0
2441        * m + 4: r1
2442        * m + 5: g1
2443        * m + 6: b1
2444        * m + 7: a1
2445        */
2446       if (brw->has_compr4) {
2447          /* By setting the high bit of the MRF register number, we
2448           * indicate that we want COMPR4 mode - instead of doing the
2449           * usual destination + 1 for the second half we get
2450           * destination + 4.
2451           */
2452          inst = emit(MOV(fs_reg(MRF, BRW_MRF_COMPR4 + first_color_mrf + index,
2453                                 color.type),
2454                          color));
2455          inst->saturate = c->key.clamp_fragment_color;
2456       } else {
2457          push_force_uncompressed();
2458          inst = emit(MOV(fs_reg(MRF, first_color_mrf + index, color.type),
2459                          color));
2460          inst->saturate = c->key.clamp_fragment_color;
2461          pop_force_uncompressed();
2462
2463          push_force_sechalf();
2464          color.sechalf = true;
2465          inst = emit(MOV(fs_reg(MRF, first_color_mrf + index + 4, color.type),
2466                          color));
2467          inst->saturate = c->key.clamp_fragment_color;
2468          pop_force_sechalf();
2469          color.sechalf = false;
2470       }
2471    }
2472 }
2473
2474 void
2475 fs_visitor::emit_fb_writes()
2476 {
2477    this->current_annotation = "FB write header";
2478    bool header_present = true;
2479    /* We can potentially have a message length of up to 15, so we have to set
2480     * base_mrf to either 0 or 1 in order to fit in m0..m15.
2481     */
2482    int base_mrf = 1;
2483    int nr = base_mrf;
2484    int reg_width = dispatch_width / 8;
2485    bool do_dual_src = this->dual_src_output.file != BAD_FILE;
2486    bool src0_alpha_to_render_target = false;
2487
2488    if (dispatch_width == 16 && do_dual_src) {
2489       fail("GL_ARB_blend_func_extended not yet supported in 16-wide.");
2490       do_dual_src = false;
2491    }
2492
2493    /* From the Sandy Bridge PRM, volume 4, page 198:
2494     *
2495     *     "Dispatched Pixel Enables. One bit per pixel indicating
2496     *      which pixels were originally enabled when the thread was
2497     *      dispatched. This field is only required for the end-of-
2498     *      thread message and on all dual-source messages."
2499     */
2500    if (brw->gen >= 6 &&
2501        !this->fp->UsesKill &&
2502        !do_dual_src &&
2503        c->key.nr_color_regions == 1) {
2504       header_present = false;
2505    }
2506
2507    if (header_present) {
2508       src0_alpha_to_render_target = brw->gen >= 6 &&
2509                                     !do_dual_src &&
2510                                     c->key.replicate_alpha;
2511       /* m2, m3 header */
2512       nr += 2;
2513    }
2514
2515    if (c->aa_dest_stencil_reg) {
2516       push_force_uncompressed();
2517       emit(MOV(fs_reg(MRF, nr++),
2518                fs_reg(brw_vec8_grf(c->aa_dest_stencil_reg, 0))));
2519       pop_force_uncompressed();
2520    }
2521
2522    /* Reserve space for color. It'll be filled in per MRT below. */
2523    int color_mrf = nr;
2524    nr += 4 * reg_width;
2525    if (do_dual_src)
2526       nr += 4;
2527    if (src0_alpha_to_render_target)
2528       nr += reg_width;
2529
2530    if (c->source_depth_to_render_target) {
2531       if (brw->gen == 6 && dispatch_width == 16) {
2532          /* For outputting oDepth on gen6, SIMD8 writes have to be
2533           * used.  This would require 8-wide moves of each half to
2534           * message regs, kind of like pre-gen5 SIMD16 FB writes.
2535           * Just bail on doing so for now.
2536           */
2537          fail("Missing support for simd16 depth writes on gen6\n");
2538       }
2539
2540       if (prog->OutputsWritten & BITFIELD64_BIT(FRAG_RESULT_DEPTH)) {
2541          /* Hand over gl_FragDepth. */
2542          assert(this->frag_depth.file != BAD_FILE);
2543          emit(MOV(fs_reg(MRF, nr), this->frag_depth));
2544       } else {
2545          /* Pass through the payload depth. */
2546          emit(MOV(fs_reg(MRF, nr),
2547                   fs_reg(brw_vec8_grf(c->source_depth_reg, 0))));
2548       }
2549       nr += reg_width;
2550    }
2551
2552    if (c->dest_depth_reg) {
2553       emit(MOV(fs_reg(MRF, nr),
2554                fs_reg(brw_vec8_grf(c->dest_depth_reg, 0))));
2555       nr += reg_width;
2556    }
2557
2558    if (do_dual_src) {
2559       fs_reg src0 = this->outputs[0];
2560       fs_reg src1 = this->dual_src_output;
2561
2562       this->current_annotation = ralloc_asprintf(this->mem_ctx,
2563                                                  "FB write src0");
2564       for (int i = 0; i < 4; i++) {
2565          fs_inst *inst = emit(MOV(fs_reg(MRF, color_mrf + i, src0.type), src0));
2566          src0.reg_offset++;
2567          inst->saturate = c->key.clamp_fragment_color;
2568       }
2569
2570       this->current_annotation = ralloc_asprintf(this->mem_ctx,
2571                                                  "FB write src1");
2572       for (int i = 0; i < 4; i++) {
2573          fs_inst *inst = emit(MOV(fs_reg(MRF, color_mrf + 4 + i, src1.type),
2574                                   src1));
2575          src1.reg_offset++;
2576          inst->saturate = c->key.clamp_fragment_color;
2577       }
2578
2579       if (INTEL_DEBUG & DEBUG_SHADER_TIME)
2580          emit_shader_time_end();
2581
2582       fs_inst *inst = emit(FS_OPCODE_FB_WRITE);
2583       inst->target = 0;
2584       inst->base_mrf = base_mrf;
2585       inst->mlen = nr - base_mrf;
2586       inst->eot = true;
2587       inst->header_present = header_present;
2588
2589       c->prog_data.dual_src_blend = true;
2590       this->current_annotation = NULL;
2591       return;
2592    }
2593
2594    for (int target = 0; target < c->key.nr_color_regions; target++) {
2595       this->current_annotation = ralloc_asprintf(this->mem_ctx,
2596                                                  "FB write target %d",
2597                                                  target);
2598       /* If src0_alpha_to_render_target is true, include source zero alpha
2599        * data in RenderTargetWrite message for targets > 0.
2600        */
2601       int write_color_mrf = color_mrf;
2602       if (src0_alpha_to_render_target && target != 0) {
2603          fs_inst *inst;
2604          fs_reg color = outputs[0];
2605          color.reg_offset += 3;
2606
2607          inst = emit(MOV(fs_reg(MRF, write_color_mrf, color.type),
2608                          color));
2609          inst->saturate = c->key.clamp_fragment_color;
2610          write_color_mrf = color_mrf + reg_width;
2611       }
2612
2613       for (unsigned i = 0; i < this->output_components[target]; i++)
2614          emit_color_write(target, i, write_color_mrf);
2615
2616       bool eot = false;
2617       if (target == c->key.nr_color_regions - 1) {
2618          eot = true;
2619
2620          if (INTEL_DEBUG & DEBUG_SHADER_TIME)
2621             emit_shader_time_end();
2622       }
2623
2624       fs_inst *inst = emit(FS_OPCODE_FB_WRITE);
2625       inst->target = target;
2626       inst->base_mrf = base_mrf;
2627       if (src0_alpha_to_render_target && target == 0)
2628          inst->mlen = nr - base_mrf - reg_width;
2629       else
2630          inst->mlen = nr - base_mrf;
2631       inst->eot = eot;
2632       inst->header_present = header_present;
2633    }
2634
2635    if (c->key.nr_color_regions == 0) {
2636       /* Even if there's no color buffers enabled, we still need to send
2637        * alpha out the pipeline to our null renderbuffer to support
2638        * alpha-testing, alpha-to-coverage, and so on.
2639        */
2640       emit_color_write(0, 3, color_mrf);
2641
2642       if (INTEL_DEBUG & DEBUG_SHADER_TIME)
2643          emit_shader_time_end();
2644
2645       fs_inst *inst = emit(FS_OPCODE_FB_WRITE);
2646       inst->base_mrf = base_mrf;
2647       inst->mlen = nr - base_mrf;
2648       inst->eot = true;
2649       inst->header_present = header_present;
2650    }
2651
2652    this->current_annotation = NULL;
2653 }
2654
2655 void
2656 fs_visitor::resolve_ud_negate(fs_reg *reg)
2657 {
2658    if (reg->type != BRW_REGISTER_TYPE_UD ||
2659        !reg->negate)
2660       return;
2661
2662    fs_reg temp = fs_reg(this, glsl_type::uint_type);
2663    emit(MOV(temp, *reg));
2664    *reg = temp;
2665 }
2666
2667 void
2668 fs_visitor::resolve_bool_comparison(ir_rvalue *rvalue, fs_reg *reg)
2669 {
2670    if (rvalue->type != glsl_type::bool_type)
2671       return;
2672
2673    fs_reg temp = fs_reg(this, glsl_type::bool_type);
2674    emit(AND(temp, *reg, fs_reg(1)));
2675    *reg = temp;
2676 }
2677
2678 fs_visitor::fs_visitor(struct brw_context *brw,
2679                        struct brw_wm_compile *c,
2680                        struct gl_shader_program *shader_prog,
2681                        struct gl_fragment_program *fp,
2682                        unsigned dispatch_width)
2683    : dispatch_width(dispatch_width)
2684 {
2685    this->c = c;
2686    this->brw = brw;
2687    this->fp = fp;
2688    this->prog = &fp->Base;
2689    this->shader_prog = shader_prog;
2690    this->prog = &fp->Base;
2691    this->stage_prog_data = &c->prog_data.base;
2692    this->ctx = &brw->ctx;
2693    this->mem_ctx = ralloc_context(NULL);
2694    if (shader_prog)
2695       shader = (struct brw_shader *)
2696          shader_prog->_LinkedShaders[MESA_SHADER_FRAGMENT];
2697    else
2698       shader = NULL;
2699    this->failed = false;
2700    this->variable_ht = hash_table_ctor(0,
2701                                        hash_table_pointer_hash,
2702                                        hash_table_pointer_compare);
2703
2704    memset(this->outputs, 0, sizeof(this->outputs));
2705    memset(this->output_components, 0, sizeof(this->output_components));
2706    this->first_non_payload_grf = 0;
2707    this->max_grf = brw->gen >= 7 ? GEN7_MRF_HACK_START : BRW_MAX_GRF;
2708
2709    this->current_annotation = NULL;
2710    this->base_ir = NULL;
2711
2712    this->virtual_grf_sizes = NULL;
2713    this->virtual_grf_count = 0;
2714    this->virtual_grf_array_size = 0;
2715    this->virtual_grf_start = NULL;
2716    this->virtual_grf_end = NULL;
2717    this->live_intervals = NULL;
2718
2719    this->params_remap = NULL;
2720    this->nr_params_remap = 0;
2721
2722    this->force_uncompressed_stack = 0;
2723    this->force_sechalf_stack = 0;
2724
2725    this->spilled_any_registers = false;
2726
2727    memset(&this->param_size, 0, sizeof(this->param_size));
2728 }
2729
2730 fs_visitor::~fs_visitor()
2731 {
2732    ralloc_free(this->mem_ctx);
2733    hash_table_dtor(this->variable_ht);
2734 }