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