src/mesa/drivers/dri/i965/brw_wm_fp.c

   1 /*
   2  Copyright (C) Intel Corp.  2006.  All Rights Reserved.
   3  Intel funded Tungsten Graphics (http://www.tungstengraphics.com) to
   4  develop this 3D driver.
   5
   6  Permission is hereby granted, free of charge, to any person obtaining
   7  a copy of this software and associated documentation files (the
   8  "Software"), to deal in the Software without restriction, including
   9  without limitation the rights to use, copy, modify, merge, publish,
  10  distribute, sublicense, and/or sell copies of the Software, and to
  11  permit persons to whom the Software is furnished to do so, subject to
  12  the following conditions:
  13
  14  The above copyright notice and this permission notice (including the
  15  next paragraph) shall be included in all copies or substantial
  16  portions of the Software.
  17
  18  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  19  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  20  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
  21  IN NO EVENT SHALL THE COPYRIGHT OWNER(S) AND/OR ITS SUPPLIERS BE
  22  LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  23  OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  24  WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  25
  26  **********************************************************************/
  27  /*
  28   * Authors:
  29   *   Keith Whitwell <keith@tungstengraphics.com>
  30   */
  31
  32
  33 #include "main/glheader.h"
  34 #include "main/macros.h"
  35 #include "main/enums.h"
  36 #include "brw_context.h"
  37 #include "brw_wm.h"
  38 #include "brw_util.h"
  39
  40 #include "program/prog_parameter.h"
  41 #include "program/prog_print.h"
  42 #include "program/prog_statevars.h"
  43
  44
  45 /** An invalid texture target */
  46 #define TEX_TARGET_NONE NUM_TEXTURE_TARGETS
  47
  48 /** An invalid texture unit */
  49 #define TEX_UNIT_NONE BRW_MAX_TEX_UNIT
  50
  51 #define FIRST_INTERNAL_TEMP MAX_NV_FRAGMENT_PROGRAM_TEMPS
  52
  53 #define X    0
  54 #define Y    1
  55 #define Z    2
  56 #define W    3
  57
  58
  59 static const char *wm_opcode_strings[] = {
  60    "PIXELXY",
  61    "DELTAXY",
  62    "PIXELW",
  63    "LINTERP",
  64    "PINTERP",
  65    "CINTERP",
  66    "WPOSXY",
  67    "FB_WRITE",
  68    "FRONTFACING",
  69 };
  70
  71 #if 0
  72 static const char *wm_file_strings[] = {
  73    "PAYLOAD"
  74 };
  75 #endif
  76
  77
  78 /***********************************************************************
  79  * Source regs
  80  */
  81
  82 static struct prog_src_register src_reg(GLuint file, GLuint idx)
  83 {
  84    struct prog_src_register reg;
  85    reg.File = file;
  86    reg.Index = idx;
  87    reg.Swizzle = SWIZZLE_NOOP;
  88    reg.RelAddr = 0;
  89    reg.Negate = NEGATE_NONE;
  90    reg.Abs = 0;
  91    reg.HasIndex2 = 0;
  92    reg.RelAddr2 = 0;
  93    reg.Index2 = 0;
  94    return reg;
  95 }
  96
  97 static struct prog_src_register src_reg_from_dst(struct prog_dst_register dst)
  98 {
  99    return src_reg(dst.File, dst.Index);
 100 }
 101
 102 static struct prog_src_register src_undef( void )
 103 {
 104    return src_reg(PROGRAM_UNDEFINED, 0);
 105 }
 106
 107 static bool src_is_undef(struct prog_src_register src)
 108 {
 109    return src.File == PROGRAM_UNDEFINED;
 110 }
 111
 112 static struct prog_src_register src_swizzle( struct prog_src_register reg, int x, int y, int z, int w )
 113 {
 114    reg.Swizzle = MAKE_SWIZZLE4(x,y,z,w);
 115    return reg;
 116 }
 117
 118 static struct prog_src_register src_swizzle1( struct prog_src_register reg, int x )
 119 {
 120    return src_swizzle(reg, x, x, x, x);
 121 }
 122
 123 static struct prog_src_register src_swizzle4( struct prog_src_register reg, uint swizzle )
 124 {
 125    reg.Swizzle = swizzle;
 126    return reg;
 127 }
 128
 129
 130 /***********************************************************************
 131  * Dest regs
 132  */
 133
 134 static struct prog_dst_register dst_reg(GLuint file, GLuint idx)
 135 {
 136    struct prog_dst_register reg;
 137    reg.File = file;
 138    reg.Index = idx;
 139    reg.WriteMask = WRITEMASK_XYZW;
 140    reg.RelAddr = 0;
 141    reg.CondMask = COND_TR;
 142    reg.CondSwizzle = 0;
 143    reg.CondSrc = 0;
 144    return reg;
 145 }
 146
 147 static struct prog_dst_register dst_mask( struct prog_dst_register reg, int mask )
 148 {
 149    reg.WriteMask &= mask;
 150    return reg;
 151 }
 152
 153 static struct prog_dst_register dst_undef( void )
 154 {
 155    return dst_reg(PROGRAM_UNDEFINED, 0);
 156 }
 157
 158
 159
 160 static struct prog_dst_register get_temp( struct brw_wm_compile *c )
 161 {
 162    int bit = _mesa_ffs( ~c->fp_temp );
 163
 164    if (!bit) {
 165       printf("%s: out of temporaries\n", __FILE__);
 166       exit(1);
 167    }
 168
 169    c->fp_temp |= 1<<(bit-1);
 170    return dst_reg(PROGRAM_TEMPORARY, FIRST_INTERNAL_TEMP+(bit-1));
 171 }
 172
 173
 174 static void release_temp( struct brw_wm_compile *c, struct prog_dst_register temp )
 175 {
 176    c->fp_temp &= ~(1 << (temp.Index - FIRST_INTERNAL_TEMP));
 177 }
 178
 179
 180 /***********************************************************************
 181  * Instructions
 182  */
 183
 184 static struct prog_instruction *get_fp_inst(struct brw_wm_compile *c)
 185 {
 186    assert(c->nr_fp_insns < BRW_WM_MAX_INSN);
 187    memset(&c->prog_instructions[c->nr_fp_insns], 0,
 188           sizeof(*c->prog_instructions));
 189    return &c->prog_instructions[c->nr_fp_insns++];
 190 }
 191
 192 static struct prog_instruction *emit_insn(struct brw_wm_compile *c,
 193                                         const struct prog_instruction *inst0)
 194 {
 195    struct prog_instruction *inst = get_fp_inst(c);
 196    *inst = *inst0;
 197    return inst;
 198 }
 199
 200 static struct prog_instruction * emit_tex_op(struct brw_wm_compile *c,
 201                                        GLuint op,
 202                                        struct prog_dst_register dest,
 203                                        GLuint saturate,
 204                                        GLuint tex_src_unit,
 205                                        GLuint tex_src_target,
 206                                        GLuint tex_shadow,
 207                                        struct prog_src_register src0,
 208                                        struct prog_src_register src1,
 209                                        struct prog_src_register src2 )
 210 {
 211    struct prog_instruction *inst = get_fp_inst(c);
 212
 213    assert(tex_src_unit < BRW_MAX_TEX_UNIT ||
 214           tex_src_unit == TEX_UNIT_NONE);
 215    assert(tex_src_target < NUM_TEXTURE_TARGETS ||
 216           tex_src_target == TEX_TARGET_NONE);
 217
 218    /* update mask of which texture units are referenced by this program */
 219    if (tex_src_unit != TEX_UNIT_NONE)
 220       c->fp->tex_units_used |= (1 << tex_src_unit);
 221
 222    memset(inst, 0, sizeof(*inst));
 223
 224    inst->Opcode = op;
 225    inst->DstReg = dest;
 226    inst->SaturateMode = saturate;
 227    inst->TexSrcUnit = tex_src_unit;
 228    inst->TexSrcTarget = tex_src_target;
 229    inst->TexShadow = tex_shadow;
 230    inst->SrcReg[0] = src0;
 231    inst->SrcReg[1] = src1;
 232    inst->SrcReg[2] = src2;
 233    return inst;
 234 }
 235
 236
 237 static struct prog_instruction * emit_op(struct brw_wm_compile *c,
 238                                        GLuint op,
 239                                        struct prog_dst_register dest,
 240                                        GLuint saturate,
 241                                        struct prog_src_register src0,
 242                                        struct prog_src_register src1,
 243                                        struct prog_src_register src2 )
 244 {
 245    return emit_tex_op(c, op, dest, saturate,
 246                       TEX_UNIT_NONE, TEX_TARGET_NONE, 0,  /* unit, tgt, shadow */
 247                       src0, src1, src2);
 248 }
 249
 250
 251 /* Many Mesa opcodes produce the same value across all the result channels.
 252  * We'd rather not have to support that splatting in the opcode implementations,
 253  * and brw_wm_pass*.c wants to optimize them out by shuffling references around
 254  * anyway.  We can easily get both by emitting the opcode to one channel, and
 255  * then MOVing it to the others, which brw_wm_pass*.c already understands.
 256  */
 257 static struct prog_instruction *emit_scalar_insn(struct brw_wm_compile *c,
 258                                                  const struct prog_instruction *inst0)
 259 {
 260    struct prog_instruction *inst;
 261    unsigned int dst_chan;
 262    unsigned int other_channel_mask;
 263
 264    if (inst0->DstReg.WriteMask == 0)
 265       return NULL;
 266
 267    dst_chan = _mesa_ffs(inst0->DstReg.WriteMask) - 1;
 268    inst = get_fp_inst(c);
 269    *inst = *inst0;
 270    inst->DstReg.WriteMask = 1 << dst_chan;
 271
 272    other_channel_mask = inst0->DstReg.WriteMask & ~(1 << dst_chan);
 273    if (other_channel_mask != 0) {
 274       inst = emit_op(c,
 275                      OPCODE_MOV,
 276                      dst_mask(inst0->DstReg, other_channel_mask),
 277                      0,
 278                      src_swizzle1(src_reg_from_dst(inst0->DstReg), dst_chan),
 279                      src_undef(),
 280                      src_undef());
 281    }
 282    return inst;
 283 }
 284
 285
 286 /***********************************************************************
 287  * Special instructions for interpolation and other tasks
 288  */
 289
 290 static struct prog_src_register get_pixel_xy( struct brw_wm_compile *c )
 291 {
 292    if (src_is_undef(c->pixel_xy)) {
 293       struct prog_dst_register pixel_xy = get_temp(c);
 294       struct prog_src_register payload_r0_depth = src_reg(PROGRAM_PAYLOAD, PAYLOAD_DEPTH);
 295
 296
 297       /* Emit the out calculations, and hold onto the results.  Use
 298        * two instructions as a temporary is required.
 299        */
 300       /* pixel_xy.xy = PIXELXY payload[0];
 301        */
 302       emit_op(c,
 303               WM_PIXELXY,
 304               dst_mask(pixel_xy, WRITEMASK_XY),
 305               0,
 306               payload_r0_depth,
 307               src_undef(),
 308               src_undef());
 309
 310       c->pixel_xy = src_reg_from_dst(pixel_xy);
 311    }
 312
 313    return c->pixel_xy;
 314 }
 315
 316 static struct prog_src_register get_delta_xy( struct brw_wm_compile *c )
 317 {
 318    if (src_is_undef(c->delta_xy)) {
 319       struct prog_dst_register delta_xy = get_temp(c);
 320       struct prog_src_register pixel_xy = get_pixel_xy(c);
 321       struct prog_src_register payload_r0_depth = src_reg(PROGRAM_PAYLOAD, PAYLOAD_DEPTH);
 322
 323       /* deltas.xy = DELTAXY pixel_xy, payload[0]
 324        */
 325       emit_op(c,
 326               WM_DELTAXY,
 327               dst_mask(delta_xy, WRITEMASK_XY),
 328               0,
 329               pixel_xy,
 330               payload_r0_depth,
 331               src_undef());
 332
 333       c->delta_xy = src_reg_from_dst(delta_xy);
 334    }
 335
 336    return c->delta_xy;
 337 }
 338
 339 static struct prog_src_register get_pixel_w( struct brw_wm_compile *c )
 340 {
 341    /* This is called for producing 1/w in pre-gen6 interp.  for gen6,
 342     * the interp opcodes don't use this argument.  But to keep the
 343     * nr_args = 3 expectations of pinterp happy, just stuff delta_xy
 344     * into the slot.
 345     */
 346    if (c->func.brw->intel.gen >= 6)
 347       return c->delta_xy;
 348
 349    if (src_is_undef(c->pixel_w)) {
 350       struct prog_dst_register pixel_w = get_temp(c);
 351       struct prog_src_register deltas = get_delta_xy(c);
 352       struct prog_src_register interp_wpos = src_reg(PROGRAM_PAYLOAD, FRAG_ATTRIB_WPOS);
 353
 354       /* deltas.xyw = DELTAS2 deltas.xy, payload.interp_wpos.x
 355        */
 356       emit_op(c,
 357               WM_PIXELW,
 358               dst_mask(pixel_w, WRITEMASK_W),
 359               0,
 360               interp_wpos,
 361               deltas,
 362               src_undef());
 363
 364
 365       c->pixel_w = src_reg_from_dst(pixel_w);
 366    }
 367
 368    return c->pixel_w;
 369 }
 370
 371 static void emit_interp( struct brw_wm_compile *c,
 372                          GLuint idx )
 373 {
 374    struct prog_dst_register dst = dst_reg(PROGRAM_INPUT, idx);
 375    struct prog_src_register interp = src_reg(PROGRAM_PAYLOAD, idx);
 376    struct prog_src_register deltas;
 377
 378    deltas = get_delta_xy(c);
 379
 380    /* Need to use PINTERP on attributes which have been
 381     * multiplied by 1/W in the SF program, and LINTERP on those
 382     * which have not:
 383     */
 384    switch (idx) {
 385    case FRAG_ATTRIB_WPOS:
 386       /* Have to treat wpos.xy specially:
 387        */
 388       emit_op(c,
 389               WM_WPOSXY,
 390               dst_mask(dst, WRITEMASK_XY),
 391               0,
 392               get_pixel_xy(c),
 393               src_undef(),
 394               src_undef());
 395
 396       dst = dst_mask(dst, WRITEMASK_ZW);
 397
 398       /* PROGRAM_INPUT.attr.xyzw = INTERP payload.interp[attr].x, deltas.xyw
 399        */
 400       emit_op(c,
 401               WM_LINTERP,
 402               dst,
 403               0,
 404               interp,
 405               deltas,
 406               src_undef());
 407       break;
 408    case FRAG_ATTRIB_COL0:
 409    case FRAG_ATTRIB_COL1:
 410       if (c->key.flat_shade) {
 411          emit_op(c,
 412                  WM_CINTERP,
 413                  dst,
 414                  0,
 415                  interp,
 416                  src_undef(),
 417                  src_undef());
 418       }
 419       else {
 420          /* perspective-corrected color interpolation */
 421          emit_op(c,
 422                  WM_PINTERP,
 423                  dst,
 424                  0,
 425                  interp,
 426                  deltas,
 427                  get_pixel_w(c));
 428       }
 429       break;
 430    case FRAG_ATTRIB_FOGC:
 431       /* Interpolate the fog coordinate */
 432       emit_op(c,
 433               WM_PINTERP,
 434               dst_mask(dst, WRITEMASK_X),
 435               0,
 436               interp,
 437               deltas,
 438               get_pixel_w(c));
 439
 440       emit_op(c,
 441               OPCODE_MOV,
 442               dst_mask(dst, WRITEMASK_YZW),
 443               0,
 444               src_swizzle(interp,
 445                           SWIZZLE_ZERO,
 446                           SWIZZLE_ZERO,
 447                           SWIZZLE_ZERO,
 448                           SWIZZLE_ONE),
 449               src_undef(),
 450               src_undef());
 451       break;
 452
 453    case FRAG_ATTRIB_FACE:
 454       emit_op(c,
 455               WM_FRONTFACING,
 456               dst_mask(dst, WRITEMASK_X),
 457               0,
 458               src_undef(),
 459               src_undef(),
 460               src_undef());
 461       break;
 462
 463    case FRAG_ATTRIB_PNTC:
 464       /* XXX review/test this case */
 465       emit_op(c,
 466               WM_PINTERP,
 467               dst_mask(dst, WRITEMASK_XY),
 468               0,
 469               interp,
 470               deltas,
 471               get_pixel_w(c));
 472
 473       emit_op(c,
 474               OPCODE_MOV,
 475               dst_mask(dst, WRITEMASK_ZW),
 476               0,
 477               src_swizzle(interp,
 478                           SWIZZLE_ZERO,
 479                           SWIZZLE_ZERO,
 480                           SWIZZLE_ZERO,
 481                           SWIZZLE_ONE),
 482               src_undef(),
 483               src_undef());
 484       break;
 485
 486    default:
 487       emit_op(c,
 488               WM_PINTERP,
 489               dst,
 490               0,
 491               interp,
 492               deltas,
 493               get_pixel_w(c));
 494       break;
 495    }
 496
 497    c->fp_interp_emitted |= 1<<idx;
 498 }
 499
 500 /***********************************************************************
 501  * Hacks to extend the program parameter and constant lists.
 502  */
 503
 504 /* Add the fog parameters to the parameter list of the original
 505  * program, rather than creating a new list.  Doesn't really do any
 506  * harm and it's not as if the parameter handling isn't a big hack
 507  * anyway.
 508  */
 509 static struct prog_src_register search_or_add_param5(struct brw_wm_compile *c,
 510                                                      GLint s0,
 511                                                      GLint s1,
 512                                                      GLint s2,
 513                                                      GLint s3,
 514                                                      GLint s4)
 515 {
 516    struct gl_program_parameter_list *paramList = c->fp->program.Base.Parameters;
 517    gl_state_index tokens[STATE_LENGTH];
 518    GLuint idx;
 519    tokens[0] = s0;
 520    tokens[1] = s1;
 521    tokens[2] = s2;
 522    tokens[3] = s3;
 523    tokens[4] = s4;
 524
 525    idx = _mesa_add_state_reference( paramList, tokens );
 526
 527    return src_reg(PROGRAM_STATE_VAR, idx);
 528 }
 529
 530
 531 static struct prog_src_register search_or_add_const4f( struct brw_wm_compile *c,
 532                                                      GLfloat s0,
 533                                                      GLfloat s1,
 534                                                      GLfloat s2,
 535                                                      GLfloat s3)
 536 {
 537    struct gl_program_parameter_list *paramList = c->fp->program.Base.Parameters;
 538    gl_constant_value values[4];
 539    GLuint idx;
 540    GLuint swizzle;
 541    struct prog_src_register reg;
 542
 543    values[0].f = s0;
 544    values[1].f = s1;
 545    values[2].f = s2;
 546    values[3].f = s3;
 547
 548    idx = _mesa_add_unnamed_constant( paramList, values, 4, &swizzle );
 549    reg = src_reg(PROGRAM_STATE_VAR, idx);
 550    reg.Swizzle = swizzle;
 551
 552    return reg;
 553 }
 554
 555
 556
 557 /***********************************************************************
 558  * Expand various instructions here to simpler forms.
 559  */
 560 static void precalc_dst( struct brw_wm_compile *c,
 561                                const struct prog_instruction *inst )
 562 {
 563    struct prog_src_register src0 = inst->SrcReg[0];
 564    struct prog_src_register src1 = inst->SrcReg[1];
 565    struct prog_dst_register dst = inst->DstReg;
 566    struct prog_dst_register temp = get_temp(c);
 567
 568    if (dst.WriteMask & WRITEMASK_Y) {
 569       /* dst.y = mul src0.y, src1.y
 570        */
 571       emit_op(c,
 572               OPCODE_MUL,
 573               dst_mask(temp, WRITEMASK_Y),
 574               inst->SaturateMode,
 575               src0,
 576               src1,
 577               src_undef());
 578    }
 579
 580    if (dst.WriteMask & WRITEMASK_XZ) {
 581       struct prog_instruction *swz;
 582       GLuint z = GET_SWZ(src0.Swizzle, Z);
 583
 584       /* dst.xz = swz src0.1zzz
 585        */
 586       swz = emit_op(c,
 587                     OPCODE_SWZ,
 588                     dst_mask(temp, WRITEMASK_XZ),
 589                     inst->SaturateMode,
 590                     src_swizzle(src0, SWIZZLE_ONE, z, z, z),
 591                     src_undef(),
 592                     src_undef());
 593       /* Avoid letting negation flag of src0 affect our 1 constant. */
 594       swz->SrcReg[0].Negate &= ~NEGATE_X;
 595    }
 596    if (dst.WriteMask & WRITEMASK_W) {
 597       /* dst.w = mov src1.w
 598        */
 599       emit_op(c,
 600               OPCODE_MOV,
 601               dst_mask(temp, WRITEMASK_W),
 602               inst->SaturateMode,
 603               src1,
 604               src_undef(),
 605               src_undef());
 606    }
 607
 608    /* This will get optimized out in general, but it ensures that we
 609     * don't overwrite src operands in our channel-wise splitting
 610     * above.  See piglit fp-dst-aliasing-[12].
 611     */
 612    emit_op(c,
 613            OPCODE_MOV,
 614            dst,
 615            0,
 616            src_reg_from_dst(temp),
 617            src_undef(),
 618            src_undef());
 619
 620    release_temp(c, temp);
 621 }
 622
 623
 624 static void precalc_lit( struct brw_wm_compile *c,
 625                          const struct prog_instruction *inst )
 626 {
 627    struct prog_src_register src0 = inst->SrcReg[0];
 628    struct prog_dst_register dst = inst->DstReg;
 629
 630    if (dst.WriteMask & WRITEMASK_YZ) {
 631       emit_op(c,
 632               OPCODE_LIT,
 633               dst_mask(dst, WRITEMASK_YZ),
 634               inst->SaturateMode,
 635               src0,
 636               src_undef(),
 637               src_undef());
 638    }
 639
 640    if (dst.WriteMask & WRITEMASK_XW) {
 641       struct prog_instruction *swz;
 642
 643       /* dst.xw = swz src0.1111
 644        */
 645       swz = emit_op(c,
 646                     OPCODE_SWZ,
 647                     dst_mask(dst, WRITEMASK_XW),
 648                     0,
 649                     src_swizzle1(src0, SWIZZLE_ONE),
 650                     src_undef(),
 651                     src_undef());
 652       /* Avoid letting the negation flag of src0 affect our 1 constant. */
 653       swz->SrcReg[0].Negate = NEGATE_NONE;
 654    }
 655 }
 656
 657
 658 /**
 659  * Some TEX instructions require extra code, cube map coordinate
 660  * normalization, or coordinate scaling for RECT textures, etc.
 661  * This function emits those extra instructions and the TEX
 662  * instruction itself.
 663  */
 664 static void precalc_tex( struct brw_wm_compile *c,
 665                          const struct prog_instruction *inst )
 666 {
 667    struct brw_compile *p = &c->func;
 668    struct intel_context *intel = &p->brw->intel;
 669    struct prog_src_register coord;
 670    struct prog_dst_register tmpcoord = { 0 };
 671    const GLuint unit = c->fp->program.Base.SamplerUnits[inst->TexSrcUnit];
 672
 673    assert(unit < BRW_MAX_TEX_UNIT);
 674
 675    if (inst->TexSrcTarget == TEXTURE_CUBE_INDEX) {
 676        struct prog_instruction *out;
 677        struct prog_dst_register tmp0 = get_temp(c);
 678        struct prog_src_register tmp0src = src_reg_from_dst(tmp0);
 679        struct prog_dst_register tmp1 = get_temp(c);
 680        struct prog_src_register tmp1src = src_reg_from_dst(tmp1);
 681        struct prog_src_register src0 = inst->SrcReg[0];
 682
 683        /* find longest component of coord vector and normalize it */
 684        tmpcoord = get_temp(c);
 685        coord = src_reg_from_dst(tmpcoord);
 686
 687        /* tmpcoord = src0 (i.e.: coord = src0) */
 688        out = emit_op(c, OPCODE_MOV,
 689                      tmpcoord,
 690                      0,
 691                      src0,
 692                      src_undef(),
 693                      src_undef());
 694        out->SrcReg[0].Negate = NEGATE_NONE;
 695        out->SrcReg[0].Abs = 1;
 696
 697        /* tmp0 = MAX(coord.X, coord.Y) */
 698        emit_op(c, OPCODE_MAX,
 699                tmp0,
 700                0,
 701                src_swizzle1(coord, X),
 702                src_swizzle1(coord, Y),
 703                src_undef());
 704
 705        /* tmp1 = MAX(tmp0, coord.Z) */
 706        emit_op(c, OPCODE_MAX,
 707                tmp1,
 708                0,
 709                tmp0src,
 710                src_swizzle1(coord, Z),
 711                src_undef());
 712
 713        /* tmp0 = 1 / tmp1 */
 714        emit_op(c, OPCODE_RCP,
 715                dst_mask(tmp0, WRITEMASK_X),
 716                0,
 717                tmp1src,
 718                src_undef(),
 719                src_undef());
 720
 721        /* tmpCoord = src0 * tmp0 */
 722        emit_op(c, OPCODE_MUL,
 723                tmpcoord,
 724                0,
 725                src0,
 726                src_swizzle1(tmp0src, SWIZZLE_X),
 727                src_undef());
 728
 729        release_temp(c, tmp0);
 730        release_temp(c, tmp1);
 731    }
 732    else if (intel->gen < 6 && inst->TexSrcTarget == TEXTURE_RECT_INDEX) {
 733       struct prog_src_register scale =
 734          search_or_add_param5( c,
 735                                STATE_INTERNAL,
 736                                STATE_TEXRECT_SCALE,
 737                                unit,
 738                                0,0 );
 739
 740       tmpcoord = get_temp(c);
 741
 742       /* coord.xy   = MUL inst->SrcReg[0], { 1/width, 1/height }
 743        */
 744       emit_op(c,
 745               OPCODE_MUL,
 746               tmpcoord,
 747               0,
 748               inst->SrcReg[0],
 749               src_swizzle(scale,
 750                           SWIZZLE_X,
 751                           SWIZZLE_Y,
 752                           SWIZZLE_ONE,
 753                           SWIZZLE_ONE),
 754               src_undef());
 755
 756       coord = src_reg_from_dst(tmpcoord);
 757    }
 758    else {
 759       coord = inst->SrcReg[0];
 760    }
 761
 762    /* Need to emit YUV texture conversions by hand.  Probably need to
 763     * do this here - the alternative is in brw_wm_emit.c, but the
 764     * conversion requires allocating a temporary variable which we
 765     * don't have the facility to do that late in the compilation.
 766     */
 767    if (c->key.yuvtex_mask & (1 << unit)) {
 768       /* convert ycbcr to RGBA */
 769       bool  swap_uv = c->key.yuvtex_swap_mask & (1<<unit);
 770
 771       /*
 772          CONST C0 = { -.5, -.0625,  -.5, 1.164 }
 773          CONST C1 = { 1.596, -0.813, 2.018, -.391 }
 774          UYV     = TEX ...
 775          UYV.xyz = ADD UYV,     C0
 776          UYV.y   = MUL UYV.y,   C0.w
 777          if (UV swaped)
 778             RGB.xyz = MAD UYV.zzx, C1,   UYV.y
 779          else
 780             RGB.xyz = MAD UYV.xxz, C1,   UYV.y
 781          RGB.y   = MAD UYV.z,   C1.w, RGB.y
 782       */
 783       struct prog_dst_register dst = inst->DstReg;
 784       struct prog_dst_register tmp = get_temp(c);
 785       struct prog_src_register tmpsrc = src_reg_from_dst(tmp);
 786       struct prog_src_register C0 = search_or_add_const4f( c,  -.5, -.0625, -.5, 1.164 );
 787       struct prog_src_register C1 = search_or_add_const4f( c, 1.596, -0.813, 2.018, -.391 );
 788
 789       /* tmp     = TEX ...
 790        */
 791       emit_tex_op(c,
 792                   OPCODE_TEX,
 793                   tmp,
 794                   inst->SaturateMode,
 795                   unit,
 796                   inst->TexSrcTarget,
 797                   inst->TexShadow,
 798                   coord,
 799                   src_undef(),
 800                   src_undef());
 801
 802       /* tmp.xyz =  ADD TMP, C0
 803        */
 804       emit_op(c,
 805               OPCODE_ADD,
 806               dst_mask(tmp, WRITEMASK_XYZ),
 807               0,
 808               tmpsrc,
 809               C0,
 810               src_undef());
 811
 812       /* YUV.y   = MUL YUV.y, C0.w
 813        */
 814
 815       emit_op(c,
 816               OPCODE_MUL,
 817               dst_mask(tmp, WRITEMASK_Y),
 818               0,
 819               tmpsrc,
 820               src_swizzle1(C0, W),
 821               src_undef());
 822
 823       /*
 824        * if (UV swaped)
 825        *     RGB.xyz = MAD YUV.zzx, C1, YUV.y
 826        * else
 827        *     RGB.xyz = MAD YUV.xxz, C1, YUV.y
 828        */
 829
 830       emit_op(c,
 831               OPCODE_MAD,
 832               dst_mask(dst, WRITEMASK_XYZ),
 833               0,
 834               swap_uv?src_swizzle(tmpsrc, Z,Z,X,X):src_swizzle(tmpsrc, X,X,Z,Z),
 835               C1,
 836               src_swizzle1(tmpsrc, Y));
 837
 838       /*  RGB.y   = MAD YUV.z, C1.w, RGB.y
 839        */
 840       emit_op(c,
 841               OPCODE_MAD,
 842               dst_mask(dst, WRITEMASK_Y),
 843               0,
 844               src_swizzle1(tmpsrc, Z),
 845               src_swizzle1(C1, W),
 846               src_swizzle1(src_reg_from_dst(dst), Y));
 847
 848       release_temp(c, tmp);
 849    }
 850    else {
 851       /* ordinary RGBA tex instruction */
 852       emit_tex_op(c,
 853                   OPCODE_TEX,
 854                   inst->DstReg,
 855                   inst->SaturateMode,
 856                   unit,
 857                   inst->TexSrcTarget,
 858                   inst->TexShadow,
 859                   coord,
 860                   src_undef(),
 861                   src_undef());
 862    }
 863
 864    /* For GL_EXT_texture_swizzle: */
 865    if (c->key.tex_swizzles[unit] != SWIZZLE_NOOP) {
 866       /* swizzle the result of the TEX instruction */
 867       struct prog_src_register tmpsrc = src_reg_from_dst(inst->DstReg);
 868       emit_op(c, OPCODE_SWZ,
 869               inst->DstReg,
 870               SATURATE_OFF, /* saturate already done above */
 871               src_swizzle4(tmpsrc, c->key.tex_swizzles[unit]),
 872               src_undef(),
 873               src_undef());
 874    }
 875
 876    if ((inst->TexSrcTarget == TEXTURE_RECT_INDEX) ||
 877        (inst->TexSrcTarget == TEXTURE_CUBE_INDEX))
 878       release_temp(c, tmpcoord);
 879 }
 880
 881
 882 /**
 883  * Check if the given TXP instruction really needs the divide-by-W step.
 884  */
 885 static bool
 886 projtex(struct brw_wm_compile *c, const struct prog_instruction *inst)
 887 {
 888    const struct prog_src_register src = inst->SrcReg[0];
 889    bool retVal;
 890
 891    assert(inst->Opcode == OPCODE_TXP);
 892
 893    /* Only try to detect the simplest cases.  Could detect (later)
 894     * cases where we are trying to emit code like RCP {1.0}, MUL x,
 895     * {1.0}, and so on.
 896     *
 897     * More complex cases than this typically only arise from
 898     * user-provided fragment programs anyway:
 899     */
 900    if (inst->TexSrcTarget == TEXTURE_CUBE_INDEX)
 901       retVal = false;  /* ut2004 gun rendering !?! */
 902    else if (src.File == PROGRAM_INPUT &&
 903             GET_SWZ(src.Swizzle, W) == W &&
 904             (c->key.proj_attrib_mask & (1 << src.Index)) == 0)
 905       retVal = false;
 906    else
 907       retVal = true;
 908
 909    return retVal;
 910 }
 911
 912
 913 /**
 914  * Emit code for TXP.
 915  */
 916 static void precalc_txp( struct brw_wm_compile *c,
 917                                const struct prog_instruction *inst )
 918 {
 919    struct prog_src_register src0 = inst->SrcReg[0];
 920
 921    if (projtex(c, inst)) {
 922       struct prog_dst_register tmp = get_temp(c);
 923       struct prog_instruction tmp_inst;
 924
 925       /* tmp0.w = RCP inst.arg[0][3]
 926        */
 927       emit_op(c,
 928               OPCODE_RCP,
 929               dst_mask(tmp, WRITEMASK_W),
 930               0,
 931               src_swizzle1(src0, GET_SWZ(src0.Swizzle, W)),
 932               src_undef(),
 933               src_undef());
 934
 935       /* tmp0.xyz =  MUL inst.arg[0], tmp0.wwww
 936        */
 937       emit_op(c,
 938               OPCODE_MUL,
 939               dst_mask(tmp, WRITEMASK_XYZ),
 940               0,
 941               src0,
 942               src_swizzle1(src_reg_from_dst(tmp), W),
 943               src_undef());
 944
 945       /* dst = precalc(TEX tmp0)
 946        */
 947       tmp_inst = *inst;
 948       tmp_inst.SrcReg[0] = src_reg_from_dst(tmp);
 949       precalc_tex(c, &tmp_inst);
 950
 951       release_temp(c, tmp);
 952    }
 953    else
 954    {
 955       /* dst = precalc(TEX src0)
 956        */
 957       precalc_tex(c, inst);
 958    }
 959 }
 960
 961
 962
 963 static void emit_render_target_writes( struct brw_wm_compile *c )
 964 {
 965    struct prog_src_register payload_r0_depth = src_reg(PROGRAM_PAYLOAD, PAYLOAD_DEPTH);
 966    struct prog_src_register outdepth = src_reg(PROGRAM_OUTPUT, FRAG_RESULT_DEPTH);
 967    struct prog_src_register outcolor;
 968    GLuint i;
 969
 970    struct prog_instruction *inst = NULL;
 971
 972    /* The inst->Aux field is used for FB write target and the EOT marker */
 973
 974    for (i = 0; i < c->key.nr_color_regions; i++) {
 975       if (c->fp->program.Base.OutputsWritten & (1 << FRAG_RESULT_COLOR)) {
 976          outcolor = src_reg(PROGRAM_OUTPUT, FRAG_RESULT_COLOR);
 977       } else {
 978          outcolor = src_reg(PROGRAM_OUTPUT, FRAG_RESULT_DATA0 + i);
 979       }
 980       inst = emit_op(c, WM_FB_WRITE, dst_mask(dst_undef(), 0),
 981                      0, outcolor, payload_r0_depth, outdepth);
 982       inst->Aux = INST_AUX_TARGET(i);
 983    }
 984
 985    /* Mark the last FB write as final, or emit a dummy write if we had
 986     * no render targets bound.
 987     */
 988    if (c->key.nr_color_regions != 0) {
 989       inst->Aux |= INST_AUX_EOT;
 990    } else {
 991       inst = emit_op(c, WM_FB_WRITE, dst_mask(dst_undef(), 0),
 992                      0, src_reg(PROGRAM_OUTPUT, FRAG_RESULT_COLOR),
 993                      payload_r0_depth, outdepth);
 994       inst->Aux = INST_AUX_TARGET(0) | INST_AUX_EOT;
 995    }
 996 }
 997
 998
 999
1000
1001 /***********************************************************************
1002  * Emit INTERP instructions ahead of first use of each attrib.
1003  */
1004
1005 static void validate_src_regs( struct brw_wm_compile *c,
1006                                const struct prog_instruction *inst )
1007 {
1008    GLuint nr_args = brw_wm_nr_args( inst->Opcode );
1009    GLuint i;
1010
1011    for (i = 0; i < nr_args; i++) {
1012       if (inst->SrcReg[i].File == PROGRAM_INPUT) {
1013          GLuint idx = inst->SrcReg[i].Index;
1014          if (!(c->fp_interp_emitted & (1<<idx))) {
1015             emit_interp(c, idx);
1016          }
1017       }
1018    }
1019 }
1020
1021 static void print_insns( const struct prog_instruction *insn,
1022                          GLuint nr )
1023 {
1024    GLuint i;
1025    for (i = 0; i < nr; i++, insn++) {
1026       printf("%3d: ", i);
1027       if (insn->Opcode < MAX_OPCODE)
1028          _mesa_fprint_instruction_opt(stdout, insn, 0, PROG_PRINT_DEBUG, NULL);
1029       else if (insn->Opcode < MAX_WM_OPCODE) {
1030          GLuint idx = insn->Opcode - MAX_OPCODE;
1031
1032          _mesa_fprint_alu_instruction(stdout, insn, wm_opcode_strings[idx],
1033                                       3, PROG_PRINT_DEBUG, NULL);
1034       }
1035       else
1036          printf("965 Opcode %d\n", insn->Opcode);
1037    }
1038 }
1039
1040
1041 /**
1042  * Initial pass for fragment program code generation.
1043  * This function is used by both the GLSL and non-GLSL paths.
1044  */
1045 void brw_wm_pass_fp( struct brw_wm_compile *c )
1046 {
1047    struct intel_context *intel = &c->func.brw->intel;
1048    struct brw_fragment_program *fp = c->fp;
1049    GLuint insn;
1050
1051    if (unlikely(INTEL_DEBUG & DEBUG_WM)) {
1052       printf("pre-fp:\n");
1053       _mesa_fprint_program_opt(stdout, &fp->program.Base, PROG_PRINT_DEBUG,
1054                                true);
1055       printf("\n");
1056    }
1057
1058    c->pixel_xy = src_undef();
1059    if (intel->gen >= 6) {
1060       /* The interpolation deltas come in as the perspective pixel
1061        * location barycentric params.
1062        */
1063       c->delta_xy = src_reg(PROGRAM_PAYLOAD, PAYLOAD_DEPTH);
1064    } else {
1065       c->delta_xy = src_undef();
1066    }
1067    c->pixel_w = src_undef();
1068    c->nr_fp_insns = 0;
1069    c->fp->tex_units_used = 0x0;
1070
1071    /* Emit preamble instructions.  This is where special instructions such as
1072     * WM_CINTERP, WM_LINTERP, WM_PINTERP and WM_WPOSXY are emitted to
1073     * compute shader inputs from varying vars.
1074     */
1075    for (insn = 0; insn < fp->program.Base.NumInstructions; insn++) {
1076       const struct prog_instruction *inst = &fp->program.Base.Instructions[insn];
1077       validate_src_regs(c, inst);
1078    }
1079
1080    /* Loop over all instructions doing assorted simplifications and
1081     * transformations.
1082     */
1083    for (insn = 0; insn < fp->program.Base.NumInstructions; insn++) {
1084       const struct prog_instruction *inst = &fp->program.Base.Instructions[insn];
1085       struct prog_instruction *out;
1086
1087       /* Check for INPUT values, emit INTERP instructions where
1088        * necessary:
1089        */
1090
1091       switch (inst->Opcode) {
1092       case OPCODE_SWZ:
1093          out = emit_insn(c, inst);
1094          out->Opcode = OPCODE_MOV;
1095          break;
1096
1097       case OPCODE_ABS:
1098          out = emit_insn(c, inst);
1099          out->Opcode = OPCODE_MOV;
1100          out->SrcReg[0].Negate = NEGATE_NONE;
1101          out->SrcReg[0].Abs = 1;
1102          break;
1103
1104       case OPCODE_SUB:
1105          out = emit_insn(c, inst);
1106          out->Opcode = OPCODE_ADD;
1107          out->SrcReg[1].Negate ^= NEGATE_XYZW;
1108          break;
1109
1110       case OPCODE_SCS:
1111          out = emit_insn(c, inst);
1112          /* This should probably be done in the parser.
1113           */
1114          out->DstReg.WriteMask &= WRITEMASK_XY;
1115          break;
1116
1117       case OPCODE_DST:
1118          precalc_dst(c, inst);
1119          break;
1120
1121       case OPCODE_LIT:
1122          precalc_lit(c, inst);
1123          break;
1124
1125       case OPCODE_RSQ:
1126          out = emit_scalar_insn(c, inst);
1127          out->SrcReg[0].Abs = true;
1128          break;
1129
1130       case OPCODE_TEX:
1131          precalc_tex(c, inst);
1132          break;
1133
1134       case OPCODE_TXP:
1135          precalc_txp(c, inst);
1136          break;
1137
1138       case OPCODE_TXB:
1139          out = emit_insn(c, inst);
1140          out->TexSrcUnit = fp->program.Base.SamplerUnits[inst->TexSrcUnit];
1141          assert(out->TexSrcUnit < BRW_MAX_TEX_UNIT);
1142          break;
1143
1144       case OPCODE_XPD:
1145          out = emit_insn(c, inst);
1146          /* This should probably be done in the parser.
1147           */
1148          out->DstReg.WriteMask &= WRITEMASK_XYZ;
1149          break;
1150
1151       case OPCODE_KIL:
1152          out = emit_insn(c, inst);
1153          /* This should probably be done in the parser.
1154           */
1155          out->DstReg.WriteMask = 0;
1156          break;
1157       case OPCODE_END:
1158          emit_render_target_writes(c);
1159          break;
1160       case OPCODE_PRINT:
1161          break;
1162       default:
1163          if (brw_wm_is_scalar_result(inst->Opcode))
1164             emit_scalar_insn(c, inst);
1165          else
1166             emit_insn(c, inst);
1167          break;
1168       }
1169    }
1170
1171    if (unlikely(INTEL_DEBUG & DEBUG_WM)) {
1172       printf("pass_fp:\n");
1173       print_insns( c->prog_instructions, c->nr_fp_insns );
1174       printf("\n");
1175    }
1176 }
1177