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