src/gallium/auxiliary/draw/draw_vs_aos.c

   1 /*
   2  * Mesa 3-D graphics library
   3  * Version:  6.3
   4  *
   5  * Copyright (C) 1999-2004  Brian Paul   All Rights Reserved.
   6  *
   7  * Permission is hereby granted, free of charge, to any person obtaining a
   8  * copy of this software and associated documentation files (the "Software"),
   9  * to deal in the Software without restriction, including without limitation
  10  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  11  * and/or sell copies of the Software, and to permit persons to whom the
  12  * Software is furnished to do so, subject to the following conditions:
  13  *
  14  * The above copyright notice and this permission notice shall be included
  15  * in all copies or substantial portions of the Software.
  16  *
  17  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  18  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  19  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  20  * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
  21  * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  22  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  23  */
  24
  25 /**
  26  * Translate tgsi vertex programs to x86/x87/SSE/SSE2 machine code
  27  * using the rtasm runtime assembler.  Based on the old
  28  * t_vb_arb_program_sse.c
  29  */
  30
  31
  32 #include "util/u_memory.h"
  33 #include "util/u_math.h"
  34 #include "pipe/p_shader_tokens.h"
  35 #include "util/u_debug.h"
  36 #include "tgsi/tgsi_parse.h"
  37 #include "tgsi/tgsi_util.h"
  38 #include "tgsi/tgsi_exec.h"
  39 #include "tgsi/tgsi_dump.h"
  40
  41 #include "draw_vs.h"
  42 #include "draw_vs_aos.h"
  43
  44 #include "rtasm/rtasm_x86sse.h"
  45
  46 #ifdef PIPE_ARCH_X86
  47 #define DISASSEM 0
  48 #define FAST_MATH 1
  49
  50 static const char *files[] =
  51 {
  52    "NULL",
  53    "CONST",
  54    "IN",
  55    "OUT",
  56    "TEMP",
  57    "SAMP",
  58    "ADDR",
  59    "IMM",
  60    "INTERNAL",
  61 };
  62
  63 static INLINE boolean eq( struct x86_reg a,
  64                             struct x86_reg b )
  65 {
  66    return (a.file == b.file &&
  67            a.idx == b.idx &&
  68            a.mod == b.mod &&
  69            a.disp == b.disp);
  70 }
  71
  72 struct x86_reg aos_get_x86( struct aos_compilation *cp,
  73                             unsigned which_reg, /* quick hack */
  74                             unsigned value )
  75 {
  76    struct x86_reg reg;
  77
  78    if (which_reg == 0)
  79       reg = cp->temp_EBP;
  80    else
  81       reg = cp->tmp_EAX;
  82
  83    if (cp->x86_reg[which_reg] != value) {
  84       unsigned offset;
  85
  86       switch (value) {
  87       case X86_IMMEDIATES:
  88          assert(which_reg == 0);
  89          offset = Offset(struct aos_machine, immediates);
  90          break;
  91       case X86_CONSTANTS:
  92          assert(which_reg == 1);
  93          offset = Offset(struct aos_machine, constants);
  94          break;
  95       case X86_BUFFERS:
  96          assert(which_reg == 0);
  97          offset = Offset(struct aos_machine, buffer);
  98          break;
  99       default:
 100          assert(0);
 101          offset = 0;
 102       }
 103
 104
 105       x86_mov(cp->func, reg,
 106               x86_make_disp(cp->machine_EDX, offset));
 107
 108       cp->x86_reg[which_reg] = value;
 109    }
 110
 111    return reg;
 112 }
 113
 114
 115 static struct x86_reg get_reg_ptr(struct aos_compilation *cp,
 116                                   unsigned file,
 117                                   unsigned idx )
 118 {
 119    struct x86_reg ptr = cp->machine_EDX;
 120
 121    switch (file) {
 122    case TGSI_FILE_INPUT:
 123       assert(idx < MAX_INPUTS);
 124       return x86_make_disp(ptr, Offset(struct aos_machine, input[idx]));
 125
 126    case TGSI_FILE_OUTPUT:
 127       return x86_make_disp(ptr, Offset(struct aos_machine, output[idx]));
 128
 129    case TGSI_FILE_TEMPORARY:
 130       assert(idx < MAX_TEMPS);
 131       return x86_make_disp(ptr, Offset(struct aos_machine, temp[idx]));
 132
 133    case AOS_FILE_INTERNAL:
 134       assert(idx < MAX_INTERNALS);
 135       return x86_make_disp(ptr, Offset(struct aos_machine, internal[idx]));
 136
 137    case TGSI_FILE_IMMEDIATE:
 138       assert(idx < MAX_IMMEDIATES);  /* just a sanity check */
 139       return x86_make_disp(aos_get_x86(cp, 0, X86_IMMEDIATES), idx * 4 * sizeof(float));
 140
 141    case TGSI_FILE_CONSTANT:
 142       assert(idx < MAX_CONSTANTS);  /* just a sanity check */
 143       return x86_make_disp(aos_get_x86(cp, 1, X86_CONSTANTS), idx * 4 * sizeof(float));
 144
 145    default:
 146       AOS_ERROR(cp, "unknown reg file");
 147       return x86_make_reg(0,0);
 148    }
 149 }
 150
 151
 152
 153 #define X87_CW_EXCEPTION_INV_OP       (1<<0)
 154 #define X87_CW_EXCEPTION_DENORM_OP    (1<<1)
 155 #define X87_CW_EXCEPTION_ZERO_DIVIDE  (1<<2)
 156 #define X87_CW_EXCEPTION_OVERFLOW     (1<<3)
 157 #define X87_CW_EXCEPTION_UNDERFLOW    (1<<4)
 158 #define X87_CW_EXCEPTION_PRECISION    (1<<5)
 159 #define X87_CW_PRECISION_SINGLE       (0<<8)
 160 #define X87_CW_PRECISION_RESERVED     (1<<8)
 161 #define X87_CW_PRECISION_DOUBLE       (2<<8)
 162 #define X87_CW_PRECISION_DOUBLE_EXT   (3<<8)
 163 #define X87_CW_PRECISION_MASK         (3<<8)
 164 #define X87_CW_ROUND_NEAREST          (0<<10)
 165 #define X87_CW_ROUND_DOWN             (1<<10)
 166 #define X87_CW_ROUND_UP               (2<<10)
 167 #define X87_CW_ROUND_ZERO             (3<<10)
 168 #define X87_CW_ROUND_MASK             (3<<10)
 169 #define X87_CW_INFINITY               (1<<12)
 170
 171
 172
 173
 174 static void spill( struct aos_compilation *cp, unsigned idx )
 175 {
 176    if (!cp->xmm[idx].dirty ||
 177        (cp->xmm[idx].file != TGSI_FILE_INPUT && /* inputs are fetched into xmm & set dirty */
 178         cp->xmm[idx].file != TGSI_FILE_OUTPUT &&
 179         cp->xmm[idx].file != TGSI_FILE_TEMPORARY)) {
 180       AOS_ERROR(cp, "invalid spill");
 181       return;
 182    }
 183    else {
 184       struct x86_reg oldval = get_reg_ptr(cp,
 185                                           cp->xmm[idx].file,
 186                                           cp->xmm[idx].idx);
 187
 188       if (0) debug_printf("\nspill %s[%d]",
 189                           files[cp->xmm[idx].file],
 190                           cp->xmm[idx].idx);
 191
 192       assert(cp->xmm[idx].dirty);
 193       sse_movaps(cp->func, oldval, x86_make_reg(file_XMM, idx));
 194       cp->xmm[idx].dirty = 0;
 195    }
 196 }
 197
 198
 199 void aos_spill_all( struct aos_compilation *cp )
 200 {
 201    unsigned i;
 202
 203    for (i = 0; i < 8; i++) {
 204       if (cp->xmm[i].dirty)
 205          spill(cp, i);
 206       aos_release_xmm_reg(cp, i);
 207    }
 208 }
 209
 210
 211 static struct x86_reg get_xmm_writable( struct aos_compilation *cp,
 212                                         struct x86_reg reg )
 213 {
 214    if (reg.file != file_XMM ||
 215        cp->xmm[reg.idx].file != TGSI_FILE_NULL)
 216    {
 217       struct x86_reg tmp = aos_get_xmm_reg(cp);
 218       sse_movaps(cp->func, tmp, reg);
 219       reg = tmp;
 220    }
 221
 222    cp->xmm[reg.idx].last_used = cp->insn_counter;
 223    return reg;
 224 }
 225
 226 static struct x86_reg get_xmm( struct aos_compilation *cp,
 227                                struct x86_reg reg )
 228 {
 229    if (reg.file != file_XMM)
 230    {
 231       struct x86_reg tmp = aos_get_xmm_reg(cp);
 232       sse_movaps(cp->func, tmp, reg);
 233       reg = tmp;
 234    }
 235
 236    cp->xmm[reg.idx].last_used = cp->insn_counter;
 237    return reg;
 238 }
 239
 240
 241 /* Allocate an empty xmm register, either as a temporary or later to
 242  * "adopt" as a shader reg.
 243  */
 244 struct x86_reg aos_get_xmm_reg( struct aos_compilation *cp )
 245 {
 246    unsigned i;
 247    unsigned oldest = 0;
 248    boolean found = FALSE;
 249
 250    for (i = 0; i < 8; i++)
 251       if (cp->xmm[i].last_used != cp->insn_counter &&
 252           cp->xmm[i].file == TGSI_FILE_NULL) {
 253          oldest = i;
 254          found = TRUE;
 255       }
 256
 257    if (!found) {
 258       for (i = 0; i < 8; i++)
 259          if (cp->xmm[i].last_used < cp->xmm[oldest].last_used)
 260             oldest = i;
 261    }
 262
 263    /* Need to write out the old value?
 264     */
 265    if (cp->xmm[oldest].dirty)
 266       spill(cp, oldest);
 267
 268    assert(cp->xmm[oldest].last_used != cp->insn_counter);
 269
 270    cp->xmm[oldest].file = TGSI_FILE_NULL;
 271    cp->xmm[oldest].idx = 0;
 272    cp->xmm[oldest].dirty = 0;
 273    cp->xmm[oldest].last_used = cp->insn_counter;
 274    return x86_make_reg(file_XMM, oldest);
 275 }
 276
 277 void aos_release_xmm_reg( struct aos_compilation *cp,
 278                           unsigned idx )
 279 {
 280    cp->xmm[idx].file = TGSI_FILE_NULL;
 281    cp->xmm[idx].idx = 0;
 282    cp->xmm[idx].dirty = 0;
 283    cp->xmm[idx].last_used = 0;
 284 }
 285
 286
 287 static void aos_soft_release_xmm( struct aos_compilation *cp,
 288                                   struct x86_reg reg )
 289 {
 290    if (reg.file == file_XMM) {
 291       assert(cp->xmm[reg.idx].last_used == cp->insn_counter);
 292       cp->xmm[reg.idx].last_used = cp->insn_counter - 1;
 293    }
 294 }
 295
 296
 297
 298 /* Mark an xmm reg as holding the current copy of a shader reg.
 299  */
 300 void aos_adopt_xmm_reg( struct aos_compilation *cp,
 301                         struct x86_reg reg,
 302                         unsigned file,
 303                         unsigned idx,
 304                         unsigned dirty )
 305 {
 306    unsigned i;
 307
 308    if (reg.file != file_XMM) {
 309       assert(0);
 310       return;
 311    }
 312
 313
 314    /* If any xmm reg thinks it holds this shader reg, break the
 315     * illusion.
 316     */
 317    for (i = 0; i < 8; i++) {
 318       if (cp->xmm[i].file == file &&
 319           cp->xmm[i].idx == idx)
 320       {
 321          /* If an xmm reg is already holding this shader reg, take into account its
 322           * dirty flag...
 323           */
 324          dirty |= cp->xmm[i].dirty;
 325          aos_release_xmm_reg(cp, i);
 326       }
 327    }
 328
 329    cp->xmm[reg.idx].file = file;
 330    cp->xmm[reg.idx].idx = idx;
 331    cp->xmm[reg.idx].dirty = dirty;
 332    cp->xmm[reg.idx].last_used = cp->insn_counter;
 333 }
 334
 335
 336 /* Return a pointer to the in-memory copy of the reg, making sure it is uptodate.
 337  */
 338 static struct x86_reg aos_get_shader_reg_ptr( struct aos_compilation *cp,
 339                                               unsigned file,
 340                                               unsigned idx )
 341 {
 342    unsigned i;
 343
 344    /* Ensure the in-memory copy of this reg is up-to-date
 345     */
 346    for (i = 0; i < 8; i++) {
 347       if (cp->xmm[i].file == file &&
 348           cp->xmm[i].idx == idx &&
 349           cp->xmm[i].dirty) {
 350          spill(cp, i);
 351       }
 352    }
 353
 354    return get_reg_ptr( cp, file, idx );
 355 }
 356
 357
 358 /* As above, but return a pointer.  Note - this pointer may alias
 359  * those returned by get_arg_ptr().
 360  */
 361 static struct x86_reg get_dst_ptr( struct aos_compilation *cp,
 362                                    const struct tgsi_full_dst_register *dst )
 363 {
 364    unsigned file = dst->Register.File;
 365    unsigned idx = dst->Register.Index;
 366    unsigned i;
 367
 368
 369    /* Ensure in-memory copy of this reg is up-to-date and invalidate
 370     * any xmm copies.
 371     */
 372    for (i = 0; i < 8; i++) {
 373       if (cp->xmm[i].file == file &&
 374           cp->xmm[i].idx == idx)
 375       {
 376          if (cp->xmm[i].dirty)
 377             spill(cp, i);
 378
 379          aos_release_xmm_reg(cp, i);
 380       }
 381    }
 382
 383    return get_reg_ptr( cp, file, idx );
 384 }
 385
 386
 387
 388
 389
 390 /* Return an XMM reg if the argument is resident, otherwise return a
 391  * base+offset pointer to the saved value.
 392  */
 393 struct x86_reg aos_get_shader_reg( struct aos_compilation *cp,
 394                                    unsigned file,
 395                                    unsigned idx )
 396 {
 397    unsigned i;
 398
 399    for (i = 0; i < 8; i++) {
 400       if (cp->xmm[i].file == file &&
 401           cp->xmm[i].idx  == idx)
 402       {
 403          cp->xmm[i].last_used = cp->insn_counter;
 404          return x86_make_reg(file_XMM, i);
 405       }
 406    }
 407
 408    /* If not found in the XMM register file, return an indirect
 409     * reference to the in-memory copy:
 410     */
 411    return get_reg_ptr( cp, file, idx );
 412 }
 413
 414
 415
 416 static struct x86_reg aos_get_shader_reg_xmm( struct aos_compilation *cp,
 417                                               unsigned file,
 418                                               unsigned idx )
 419 {
 420    struct x86_reg reg = get_xmm( cp,
 421                                  aos_get_shader_reg( cp, file, idx ) );
 422
 423    aos_adopt_xmm_reg( cp,
 424                       reg,
 425                       file,
 426                       idx,
 427                       FALSE );
 428
 429    return reg;
 430 }
 431
 432
 433
 434 struct x86_reg aos_get_internal_xmm( struct aos_compilation *cp,
 435                                      unsigned imm )
 436 {
 437    return aos_get_shader_reg_xmm( cp, AOS_FILE_INTERNAL, imm );
 438 }
 439
 440
 441 struct x86_reg aos_get_internal( struct aos_compilation *cp,
 442                                  unsigned imm )
 443 {
 444    return aos_get_shader_reg( cp, AOS_FILE_INTERNAL, imm );
 445 }
 446
 447
 448
 449
 450
 451 /* Emulate pshufd insn in regular SSE, if necessary:
 452  */
 453 static void emit_pshufd( struct aos_compilation *cp,
 454                          struct x86_reg dst,
 455                          struct x86_reg arg0,
 456                          ubyte shuf )
 457 {
 458    if (cp->have_sse2) {
 459       sse2_pshufd(cp->func, dst, arg0, shuf);
 460    }
 461    else {
 462       if (!eq(dst, arg0))
 463          sse_movaps(cp->func, dst, arg0);
 464
 465       sse_shufps(cp->func, dst, dst, shuf);
 466    }
 467 }
 468
 469 /* load masks (pack into negs??)
 470  * pshufd - shuffle according to writemask
 471  * and - result, mask
 472  * nand - dest, mask
 473  * or - dest, result
 474  */
 475 static boolean mask_write( struct aos_compilation *cp,
 476                            struct x86_reg dst,
 477                            struct x86_reg result,
 478                            unsigned mask )
 479 {
 480    struct x86_reg imm_swz = aos_get_internal_xmm(cp, IMM_SWZ);
 481    struct x86_reg tmp = aos_get_xmm_reg(cp);
 482
 483    emit_pshufd(cp, tmp, imm_swz,
 484                SHUF((mask & 1) ? 2 : 3,
 485                     (mask & 2) ? 2 : 3,
 486                     (mask & 4) ? 2 : 3,
 487                     (mask & 8) ? 2 : 3));
 488
 489    sse_andps(cp->func, dst, tmp);
 490    sse_andnps(cp->func, tmp, result);
 491    sse_orps(cp->func, dst, tmp);
 492
 493    aos_release_xmm_reg(cp, tmp.idx);
 494    return TRUE;
 495 }
 496
 497
 498
 499
 500 /* Helper for writemask:
 501  */
 502 static boolean emit_shuf_copy2( struct aos_compilation *cp,
 503                                   struct x86_reg dst,
 504                                   struct x86_reg arg0,
 505                                   struct x86_reg arg1,
 506                                   ubyte shuf )
 507 {
 508    struct x86_reg tmp = aos_get_xmm_reg(cp);
 509
 510    emit_pshufd(cp, dst, arg1, shuf);
 511    emit_pshufd(cp, tmp, arg0, shuf);
 512    sse_shufps(cp->func, dst, tmp, SHUF(X, Y, Z, W));
 513    emit_pshufd(cp, dst, dst, shuf);
 514
 515    aos_release_xmm_reg(cp, tmp.idx);
 516    return TRUE;
 517 }
 518
 519
 520
 521 #define SSE_SWIZZLE_NOOP ((0<<0) | (1<<2) | (2<<4) | (3<<6))
 522
 523
 524 /* Locate a source register and perform any required (simple) swizzle.
 525  *
 526  * Just fail on complex swizzles at this point.
 527  */
 528 static struct x86_reg fetch_src( struct aos_compilation *cp,
 529                                  const struct tgsi_full_src_register *src )
 530 {
 531    struct x86_reg arg0 = aos_get_shader_reg(cp,
 532                                             src->Register.File,
 533                                             src->Register.Index);
 534    unsigned i;
 535    ubyte swz = 0;
 536    unsigned negs = 0;
 537    unsigned abs = 0;
 538
 539    for (i = 0; i < 4; i++) {
 540       unsigned swizzle = tgsi_util_get_full_src_register_swizzle( src, i );
 541       unsigned neg = tgsi_util_get_full_src_register_sign_mode( src, i );
 542
 543       swz |= (swizzle & 0x3) << (i * 2);
 544
 545       switch (neg) {
 546       case TGSI_UTIL_SIGN_TOGGLE:
 547          negs |= (1<<i);
 548          break;
 549
 550       case TGSI_UTIL_SIGN_KEEP:
 551          break;
 552
 553       case TGSI_UTIL_SIGN_CLEAR:
 554          abs |= (1<<i);
 555          break;
 556
 557       default:
 558          AOS_ERROR(cp, "unsupported sign-mode");
 559          break;
 560       }
 561    }
 562
 563    if (swz != SSE_SWIZZLE_NOOP || negs != 0 || abs != 0) {
 564       struct x86_reg dst = aos_get_xmm_reg(cp);
 565
 566       if (swz != SSE_SWIZZLE_NOOP)
 567          emit_pshufd(cp, dst, arg0, swz);
 568       else
 569          sse_movaps(cp->func, dst, arg0);
 570
 571       if (negs && negs != 0xf) {
 572          struct x86_reg imm_swz = aos_get_internal_xmm(cp, IMM_SWZ);
 573          struct x86_reg tmp = aos_get_xmm_reg(cp);
 574
 575          /* Load 1,-1,0,0
 576           * Use neg as arg to pshufd
 577           * Multiply
 578           */
 579          emit_pshufd(cp, tmp, imm_swz,
 580                      SHUF((negs & 1) ? 1 : 0,
 581                           (negs & 2) ? 1 : 0,
 582                           (negs & 4) ? 1 : 0,
 583                           (negs & 8) ? 1 : 0));
 584          sse_mulps(cp->func, dst, tmp);
 585
 586          aos_release_xmm_reg(cp, tmp.idx);
 587          aos_soft_release_xmm(cp, imm_swz);
 588       }
 589       else if (negs) {
 590          struct x86_reg imm_negs = aos_get_internal_xmm(cp, IMM_NEGS);
 591          sse_mulps(cp->func, dst, imm_negs);
 592          aos_soft_release_xmm(cp, imm_negs);
 593       }
 594
 595
 596       if (abs && abs != 0xf) {
 597          AOS_ERROR(cp, "unsupported partial abs");
 598       }
 599       else if (abs) {
 600          struct x86_reg neg = aos_get_internal(cp, IMM_NEGS);
 601          struct x86_reg tmp = aos_get_xmm_reg(cp);
 602
 603          sse_movaps(cp->func, tmp, dst);
 604          sse_mulps(cp->func, tmp, neg);
 605          sse_maxps(cp->func, dst, tmp);
 606
 607          aos_release_xmm_reg(cp, tmp.idx);
 608          aos_soft_release_xmm(cp, neg);
 609       }
 610
 611       aos_soft_release_xmm(cp, arg0);
 612       return dst;
 613    }
 614
 615    return arg0;
 616 }
 617
 618 static void x87_fld_src( struct aos_compilation *cp,
 619                          const struct tgsi_full_src_register *src,
 620                          unsigned channel )
 621 {
 622    struct x86_reg arg0 = aos_get_shader_reg_ptr(cp,
 623                                                 src->Register.File,
 624                                                 src->Register.Index);
 625
 626    unsigned swizzle = tgsi_util_get_full_src_register_swizzle( src, channel );
 627    unsigned neg = tgsi_util_get_full_src_register_sign_mode( src, channel );
 628
 629    x87_fld( cp->func, x86_make_disp(arg0, (swizzle & 3) * sizeof(float)) );
 630
 631    switch (neg) {
 632    case TGSI_UTIL_SIGN_TOGGLE:
 633       /* Flip the sign:
 634        */
 635       x87_fchs( cp->func );
 636       break;
 637
 638    case TGSI_UTIL_SIGN_KEEP:
 639       break;
 640
 641    case TGSI_UTIL_SIGN_CLEAR:
 642       x87_fabs( cp->func );
 643       break;
 644
 645    case TGSI_UTIL_SIGN_SET:
 646       x87_fabs( cp->func );
 647       x87_fchs( cp->func );
 648       break;
 649
 650    default:
 651       AOS_ERROR(cp, "unsupported sign-mode");
 652       break;
 653    }
 654 }
 655
 656
 657
 658
 659
 660
 661 /* Used to implement write masking.  This and most of the other instructions
 662  * here would be easier to implement if there had been a translation
 663  * to a 2 argument format (dst/arg0, arg1) at the shader level before
 664  * attempting to translate to x86/sse code.
 665  */
 666 static void store_dest( struct aos_compilation *cp,
 667                         const struct tgsi_full_dst_register *reg,
 668                         struct x86_reg result )
 669 {
 670    struct x86_reg dst;
 671
 672    switch (reg->Register.WriteMask) {
 673    case 0:
 674       return;
 675
 676    case TGSI_WRITEMASK_XYZW:
 677       aos_adopt_xmm_reg(cp,
 678                         get_xmm_writable(cp, result),
 679                         reg->Register.File,
 680                         reg->Register.Index,
 681                         TRUE);
 682       return;
 683    default:
 684       break;
 685    }
 686
 687    dst = aos_get_shader_reg_xmm(cp,
 688                                 reg->Register.File,
 689                                 reg->Register.Index);
 690
 691    switch (reg->Register.WriteMask) {
 692    case TGSI_WRITEMASK_X:
 693       sse_movss(cp->func, dst, get_xmm(cp, result));
 694       break;
 695
 696    case TGSI_WRITEMASK_ZW:
 697       sse_shufps(cp->func, dst, get_xmm(cp, result), SHUF(X, Y, Z, W));
 698       break;
 699
 700    case TGSI_WRITEMASK_XY:
 701       result = get_xmm_writable(cp, result);
 702       sse_shufps(cp->func, result, dst, SHUF(X, Y, Z, W));
 703       dst = result;
 704       break;
 705
 706    case TGSI_WRITEMASK_YZW:
 707       result = get_xmm_writable(cp, result);
 708       sse_movss(cp->func, result, dst);
 709       dst = result;
 710       break;
 711
 712    default:
 713       mask_write(cp, dst, result, reg->Register.WriteMask);
 714       break;
 715    }
 716
 717    aos_adopt_xmm_reg(cp,
 718                      dst,
 719                      reg->Register.File,
 720                      reg->Register.Index,
 721                      TRUE);
 722
 723 }
 724
 725 static void inject_scalar( struct aos_compilation *cp,
 726                            struct x86_reg dst,
 727                            struct x86_reg result,
 728                            ubyte swizzle )
 729 {
 730    sse_shufps(cp->func, dst, dst, swizzle);
 731    sse_movss(cp->func, dst, result);
 732    sse_shufps(cp->func, dst, dst, swizzle);
 733 }
 734
 735
 736 static void store_scalar_dest( struct aos_compilation *cp,
 737                                const struct tgsi_full_dst_register *reg,
 738                                struct x86_reg result )
 739 {
 740    unsigned writemask = reg->Register.WriteMask;
 741    struct x86_reg dst;
 742
 743    if (writemask != TGSI_WRITEMASK_X &&
 744        writemask != TGSI_WRITEMASK_Y &&
 745        writemask != TGSI_WRITEMASK_Z &&
 746        writemask != TGSI_WRITEMASK_W &&
 747        writemask != 0)
 748    {
 749       result = get_xmm_writable(cp, result); /* already true, right? */
 750       sse_shufps(cp->func, result, result, SHUF(X,X,X,X));
 751       store_dest(cp, reg, result);
 752       return;
 753    }
 754
 755    result = get_xmm(cp, result);
 756    dst = aos_get_shader_reg_xmm(cp,
 757                                 reg->Register.File,
 758                                 reg->Register.Index);
 759
 760
 761
 762    switch (reg->Register.WriteMask) {
 763    case TGSI_WRITEMASK_X:
 764       sse_movss(cp->func, dst, result);
 765       break;
 766
 767    case TGSI_WRITEMASK_Y:
 768       inject_scalar(cp, dst, result, SHUF(Y, X, Z, W));
 769       break;
 770
 771    case TGSI_WRITEMASK_Z:
 772       inject_scalar(cp, dst, result, SHUF(Z, Y, X, W));
 773       break;
 774
 775    case TGSI_WRITEMASK_W:
 776       inject_scalar(cp, dst, result, SHUF(W, Y, Z, X));
 777       break;
 778
 779    default:
 780       break;
 781    }
 782
 783    aos_adopt_xmm_reg(cp,
 784                      dst,
 785                      reg->Register.File,
 786                      reg->Register.Index,
 787                      TRUE);
 788 }
 789
 790
 791
 792 static void x87_fst_or_nop( struct x86_function *func,
 793                             unsigned writemask,
 794                             unsigned channel,
 795                             struct x86_reg ptr )
 796 {
 797    assert(ptr.file == file_REG32);
 798    if (writemask & (1<<channel))
 799       x87_fst( func, x86_make_disp(ptr, channel * sizeof(float)) );
 800 }
 801
 802 static void x87_fstp_or_pop( struct x86_function *func,
 803                              unsigned writemask,
 804                              unsigned channel,
 805                              struct x86_reg ptr )
 806 {
 807    assert(ptr.file == file_REG32);
 808    if (writemask & (1<<channel))
 809       x87_fstp( func, x86_make_disp(ptr, channel * sizeof(float)) );
 810    else
 811       x87_fstp( func, x86_make_reg( file_x87, 0 ));
 812 }
 813
 814
 815
 816 /*
 817  */
 818 static void x87_fstp_dest4( struct aos_compilation *cp,
 819                             const struct tgsi_full_dst_register *dst )
 820 {
 821    struct x86_reg ptr = get_dst_ptr(cp, dst);
 822    unsigned writemask = dst->Register.WriteMask;
 823
 824    x87_fst_or_nop(cp->func, writemask, 0, ptr);
 825    x87_fst_or_nop(cp->func, writemask, 1, ptr);
 826    x87_fst_or_nop(cp->func, writemask, 2, ptr);
 827    x87_fstp_or_pop(cp->func, writemask, 3, ptr);
 828 }
 829
 830 /* Save current x87 state and put it into single precision mode.
 831  */
 832 static void save_fpu_state( struct aos_compilation *cp )
 833 {
 834    x87_fnstcw( cp->func, x86_make_disp(cp->machine_EDX,
 835                                        Offset(struct aos_machine, fpu_restore)));
 836 }
 837
 838 static void restore_fpu_state( struct aos_compilation *cp )
 839 {
 840    x87_fnclex(cp->func);
 841    x87_fldcw( cp->func, x86_make_disp(cp->machine_EDX,
 842                                       Offset(struct aos_machine, fpu_restore)));
 843 }
 844
 845 static void set_fpu_round_neg_inf( struct aos_compilation *cp )
 846 {
 847    if (cp->fpucntl != FPU_RND_NEG) {
 848       cp->fpucntl = FPU_RND_NEG;
 849       x87_fnclex(cp->func);
 850       x87_fldcw( cp->func, x86_make_disp(cp->machine_EDX,
 851                                          Offset(struct aos_machine, fpu_rnd_neg_inf)));
 852    }
 853 }
 854
 855 static void set_fpu_round_nearest( struct aos_compilation *cp )
 856 {
 857    if (cp->fpucntl != FPU_RND_NEAREST) {
 858       cp->fpucntl = FPU_RND_NEAREST;
 859       x87_fnclex(cp->func);
 860       x87_fldcw( cp->func, x86_make_disp(cp->machine_EDX,
 861                                          Offset(struct aos_machine, fpu_rnd_nearest)));
 862    }
 863 }
 864
 865 #if 0
 866 static void x87_emit_ex2( struct aos_compilation *cp )
 867 {
 868    struct x86_reg st0 = x86_make_reg(file_x87, 0);
 869    struct x86_reg st1 = x86_make_reg(file_x87, 1);
 870    int stack = cp->func->x87_stack;
 871
 872    /* set_fpu_round_neg_inf( cp ); */
 873
 874    x87_fld(cp->func, st0);      /* a a */
 875    x87_fprndint( cp->func );    /* int(a) a*/
 876    x87_fsubr(cp->func, st1, st0);    /* int(a) frc(a) */
 877    x87_fxch(cp->func, st1);     /* frc(a) int(a) */
 878    x87_f2xm1(cp->func);         /* (2^frc(a))-1 int(a) */
 879    x87_fld1(cp->func);          /* 1 (2^frc(a))-1 int(a) */
 880    x87_faddp(cp->func, st1);    /* 2^frac(a) int(a)  */
 881    x87_fscale(cp->func);        /* (2^frac(a)*2^int(int(a))) int(a) */
 882                                 /* 2^a int(a) */
 883    x87_fstp(cp->func, st1);     /* 2^a */
 884
 885    assert( stack == cp->func->x87_stack);
 886
 887 }
 888 #endif
 889
 890 #if 0
 891 static void PIPE_CDECL print_reg( const char *msg,
 892                                   const float *reg )
 893 {
 894    debug_printf("%s: %f %f %f %f\n", msg, reg[0], reg[1], reg[2], reg[3]);
 895 }
 896 #endif
 897
 898 #if 0
 899 static void emit_print( struct aos_compilation *cp,
 900                         const char *message, /* must point to a static string! */
 901                         unsigned file,
 902                         unsigned idx )
 903 {
 904    struct x86_reg ecx = x86_make_reg( file_REG32, reg_CX );
 905    struct x86_reg arg = aos_get_shader_reg_ptr( cp, file, idx );
 906    unsigned i;
 907
 908    /* There shouldn't be anything on the x87 stack.  Can add this
 909     * capacity later if need be.
 910     */
 911    assert(cp->func->x87_stack == 0);
 912
 913    /* For absolute correctness, need to spill/invalidate all XMM regs
 914     * too.  We're obviously not concerned about performance on this
 915     * debug path, so here goes:
 916     */
 917    for (i = 0; i < 8; i++) {
 918       if (cp->xmm[i].dirty)
 919          spill(cp, i);
 920
 921       aos_release_xmm_reg(cp, i);
 922    }
 923
 924    /* Push caller-save (ie scratch) regs.
 925     */
 926    x86_cdecl_caller_push_regs( cp->func );
 927
 928
 929    /* Push the arguments:
 930     */
 931    x86_lea( cp->func, ecx, arg );
 932    x86_push( cp->func, ecx );
 933    x86_push_imm32( cp->func, (int)message );
 934
 935    /* Call the helper.  Could call debug_printf directly, but
 936     * print_reg is a nice place to put a breakpoint if need be.
 937     */
 938    x86_mov_reg_imm( cp->func, ecx, (int)print_reg );
 939    x86_call( cp->func, ecx );
 940    x86_pop( cp->func, ecx );
 941    x86_pop( cp->func, ecx );
 942
 943    /* Pop caller-save regs
 944     */
 945    x86_cdecl_caller_pop_regs( cp->func );
 946
 947    /* Done...
 948     */
 949 }
 950 #endif
 951
 952 /**
 953  * The traditional instructions.  All operate on internal registers
 954  * and ignore write masks and swizzling issues.
 955  */
 956
 957 static boolean emit_ABS( struct aos_compilation *cp, const struct tgsi_full_instruction *op )
 958 {
 959    struct x86_reg arg0 = fetch_src(cp, &op->Src[0]);
 960    struct x86_reg neg = aos_get_internal(cp, IMM_NEGS);
 961    struct x86_reg tmp = aos_get_xmm_reg(cp);
 962
 963    sse_movaps(cp->func, tmp, arg0);
 964    sse_mulps(cp->func, tmp, neg);
 965    sse_maxps(cp->func, tmp, arg0);
 966
 967    store_dest(cp, &op->Dst[0], tmp);
 968    return TRUE;
 969 }
 970
 971 static boolean emit_ADD( struct aos_compilation *cp, const struct tgsi_full_instruction *op )
 972 {
 973    struct x86_reg arg0 = fetch_src(cp, &op->Src[0]);
 974    struct x86_reg arg1 = fetch_src(cp, &op->Src[1]);
 975    struct x86_reg dst = get_xmm_writable(cp, arg0);
 976
 977    sse_addps(cp->func, dst, arg1);
 978
 979    store_dest(cp, &op->Dst[0], dst);
 980    return TRUE;
 981 }
 982
 983 static boolean emit_COS( struct aos_compilation *cp, const struct tgsi_full_instruction *op )
 984 {
 985    x87_fld_src(cp, &op->Src[0], 0);
 986    x87_fcos(cp->func);
 987    x87_fstp_dest4(cp, &op->Dst[0]);
 988    return TRUE;
 989 }
 990
 991 /* The dotproduct instructions don't really do that well in sse:
 992  * XXX: produces wrong results -- disabled.
 993  */
 994 static boolean emit_DP3( struct aos_compilation *cp, const struct tgsi_full_instruction *op )
 995 {
 996    struct x86_reg arg0 = fetch_src(cp, &op->Src[0]);
 997    struct x86_reg arg1 = fetch_src(cp, &op->Src[1]);
 998    struct x86_reg tmp = aos_get_xmm_reg(cp);
 999    struct x86_reg dst = get_xmm_writable(cp, arg0);
1000
1001    sse_mulps(cp->func, dst, arg1);
1002    /* Now the hard bit: sum the first 3 values:
1003     */
1004    sse_movhlps(cp->func, tmp, dst);
1005    sse_addss(cp->func, dst, tmp); /* a*x+c*z, b*y, ?, ? */
1006    emit_pshufd(cp, tmp, dst, SHUF(Y,X,W,Z));
1007    sse_addss(cp->func, dst, tmp);
1008
1009    aos_release_xmm_reg(cp, tmp.idx);
1010    store_scalar_dest(cp, &op->Dst[0], dst);
1011    return TRUE;
1012 }
1013
1014 static boolean emit_DP4( struct aos_compilation *cp, const struct tgsi_full_instruction *op )
1015 {
1016    struct x86_reg arg0 = fetch_src(cp, &op->Src[0]);
1017    struct x86_reg arg1 = fetch_src(cp, &op->Src[1]);
1018    struct x86_reg tmp = aos_get_xmm_reg(cp);
1019    struct x86_reg dst = get_xmm_writable(cp, arg0);
1020
1021    sse_mulps(cp->func, dst, arg1);
1022
1023    /* Now the hard bit: sum the values:
1024     */
1025    sse_movhlps(cp->func, tmp, dst);
1026    sse_addps(cp->func, dst, tmp); /* a*x+c*z, b*y+d*w, a*x+c*z, b*y+d*w */
1027    emit_pshufd(cp, tmp, dst, SHUF(Y,X,W,Z));
1028    sse_addss(cp->func, dst, tmp);
1029
1030    aos_release_xmm_reg(cp, tmp.idx);
1031    store_scalar_dest(cp, &op->Dst[0], dst);
1032    return TRUE;
1033 }
1034
1035 static boolean emit_DPH( struct aos_compilation *cp, const struct tgsi_full_instruction *op )
1036 {
1037    struct x86_reg arg0 = fetch_src(cp, &op->Src[0]);
1038    struct x86_reg arg1 = fetch_src(cp, &op->Src[1]);
1039    struct x86_reg tmp = aos_get_xmm_reg(cp);
1040    struct x86_reg dst = get_xmm_writable(cp, arg0);
1041
1042    sse_mulps(cp->func, dst, arg1);
1043
1044    /* Now the hard bit: sum the values (from DP3):
1045     */
1046    sse_movhlps(cp->func, tmp, dst);
1047    sse_addss(cp->func, dst, tmp); /* a*x+c*z, b*y, ?, ? */
1048    emit_pshufd(cp, tmp, dst, SHUF(Y,X,W,Z));
1049    sse_addss(cp->func, dst, tmp);
1050    emit_pshufd(cp, tmp, arg1, SHUF(W,W,W,W));
1051    sse_addss(cp->func, dst, tmp);
1052
1053    aos_release_xmm_reg(cp, tmp.idx);
1054    store_scalar_dest(cp, &op->Dst[0], dst);
1055    return TRUE;
1056 }
1057
1058 static boolean emit_DST( struct aos_compilation *cp, const struct tgsi_full_instruction *op )
1059 {
1060     struct x86_reg arg0 = fetch_src(cp, &op->Src[0]);
1061     struct x86_reg arg1 = fetch_src(cp, &op->Src[1]);
1062     struct x86_reg dst = aos_get_xmm_reg(cp);
1063     struct x86_reg tmp = aos_get_xmm_reg(cp);
1064     struct x86_reg ones = aos_get_internal(cp, IMM_ONES);
1065
1066 /*    dst[0] = 1.0     * 1.0F; */
1067 /*    dst[1] = arg0[1] * arg1[1]; */
1068 /*    dst[2] = arg0[2] * 1.0; */
1069 /*    dst[3] = 1.0     * arg1[3]; */
1070
1071     emit_shuf_copy2(cp, dst, arg0, ones, SHUF(X,W,Z,Y));
1072     emit_shuf_copy2(cp, tmp, arg1, ones, SHUF(X,Z,Y,W));
1073     sse_mulps(cp->func, dst, tmp);
1074
1075     aos_release_xmm_reg(cp, tmp.idx);
1076     store_dest(cp, &op->Dst[0], dst);
1077     return TRUE;
1078 }
1079
1080 static boolean emit_LG2( struct aos_compilation *cp, const struct tgsi_full_instruction *op )
1081 {
1082    x87_fld1(cp->func);          /* 1 */
1083    x87_fld_src(cp, &op->Src[0], 0);     /* a0 1 */
1084    x87_fyl2x(cp->func); /* log2(a0) */
1085    x87_fstp_dest4(cp, &op->Dst[0]);
1086    return TRUE;
1087 }
1088
1089 #if 0
1090 static boolean emit_EX2( struct aos_compilation *cp, const struct tgsi_full_instruction *op )
1091 {
1092    x87_fld_src(cp, &op->Src[0], 0);
1093    x87_emit_ex2(cp);
1094    x87_fstp_dest4(cp, &op->Dst[0]);
1095    return TRUE;
1096 }
1097 #endif
1098
1099
1100 static boolean emit_FLR( struct aos_compilation *cp, const struct tgsi_full_instruction *op )
1101 {
1102    struct x86_reg dst = get_dst_ptr(cp, &op->Dst[0]);
1103    unsigned writemask = op->Dst[0].Register.WriteMask;
1104    int i;
1105
1106    set_fpu_round_neg_inf( cp );
1107
1108    /* Load all sources first to avoid aliasing
1109     */
1110    for (i = 3; i >= 0; i--) {
1111       if (writemask & (1<<i)) {
1112          x87_fld_src(cp, &op->Src[0], i);
1113       }
1114    }
1115
1116    for (i = 0; i < 4; i++) {
1117       if (writemask & (1<<i)) {
1118          x87_fprndint( cp->func );
1119          x87_fstp(cp->func, x86_make_disp(dst, i*4));
1120       }
1121    }
1122
1123    return TRUE;
1124 }
1125
1126
1127 static boolean emit_RND( struct aos_compilation *cp, const struct tgsi_full_instruction *op )
1128 {
1129    struct x86_reg dst = get_dst_ptr(cp, &op->Dst[0]);
1130    unsigned writemask = op->Dst[0].Register.WriteMask;
1131    int i;
1132
1133    set_fpu_round_nearest( cp );
1134
1135    /* Load all sources first to avoid aliasing
1136     */
1137    for (i = 3; i >= 0; i--) {
1138       if (writemask & (1<<i)) {
1139          x87_fld_src(cp, &op->Src[0], i);
1140       }
1141    }
1142
1143    for (i = 0; i < 4; i++) {
1144       if (writemask & (1<<i)) {
1145          x87_fprndint( cp->func );
1146          x87_fstp(cp->func, x86_make_disp(dst, i*4));
1147       }
1148    }
1149
1150    return TRUE;
1151 }
1152
1153
1154 static boolean emit_FRC( struct aos_compilation *cp, const struct tgsi_full_instruction *op )
1155 {
1156    struct x86_reg dst = get_dst_ptr(cp, &op->Dst[0]);
1157    struct x86_reg st0 = x86_make_reg(file_x87, 0);
1158    struct x86_reg st1 = x86_make_reg(file_x87, 1);
1159    unsigned writemask = op->Dst[0].Register.WriteMask;
1160    int i;
1161
1162    set_fpu_round_neg_inf( cp );
1163
1164    /* suck all the source values onto the stack before writing out any
1165     * dst, which may alias...
1166     */
1167    for (i = 3; i >= 0; i--) {
1168       if (writemask & (1<<i)) {
1169          x87_fld_src(cp, &op->Src[0], i);
1170       }
1171    }
1172
1173    for (i = 0; i < 4; i++) {
1174       if (writemask & (1<<i)) {
1175          x87_fld(cp->func, st0);     /* a a */
1176          x87_fprndint( cp->func );   /* flr(a) a */
1177          x87_fsubp(cp->func, st1);  /* frc(a) */
1178          x87_fstp(cp->func, x86_make_disp(dst, i*4));
1179       }
1180    }
1181
1182    return TRUE;
1183 }
1184
1185
1186
1187
1188
1189
1190 static boolean emit_LIT( struct aos_compilation *cp, const struct tgsi_full_instruction *op )
1191 {
1192    struct x86_reg ecx = x86_make_reg( file_REG32, reg_CX );
1193    unsigned writemask = op->Dst[0].Register.WriteMask;
1194    unsigned lit_count = cp->lit_count++;
1195    struct x86_reg result, arg0;
1196    unsigned i;
1197
1198 #if 1
1199    /* For absolute correctness, need to spill/invalidate all XMM regs
1200     * too.
1201     */
1202    for (i = 0; i < 8; i++) {
1203       if (cp->xmm[i].dirty)
1204          spill(cp, i);
1205       aos_release_xmm_reg(cp, i);
1206    }
1207 #endif
1208
1209    if (writemask != TGSI_WRITEMASK_XYZW)
1210       result = x86_make_disp(cp->machine_EDX, Offset(struct aos_machine, tmp[0]));
1211    else
1212       result = get_dst_ptr(cp, &op->Dst[0]);
1213
1214
1215    arg0 = fetch_src( cp, &op->Src[0] );
1216    if (arg0.file == file_XMM) {
1217       struct x86_reg tmp = x86_make_disp(cp->machine_EDX,
1218                                          Offset(struct aos_machine, tmp[1]));
1219       sse_movaps( cp->func, tmp, arg0 );
1220       arg0 = tmp;
1221    }
1222
1223
1224
1225    /* Push caller-save (ie scratch) regs.
1226     */
1227    x86_cdecl_caller_push_regs( cp->func );
1228
1229    /* Push the arguments:
1230     */
1231    x86_push_imm32( cp->func, lit_count );
1232
1233    x86_lea( cp->func, ecx, arg0 );
1234    x86_push( cp->func, ecx );
1235
1236    x86_lea( cp->func, ecx, result );
1237    x86_push( cp->func, ecx );
1238
1239    x86_push( cp->func, cp->machine_EDX );
1240
1241    if (lit_count < MAX_LIT_INFO) {
1242       x86_mov( cp->func, ecx, x86_make_disp( cp->machine_EDX,
1243                                              Offset(struct aos_machine, lit_info) +
1244                                              lit_count * sizeof(struct lit_info) +
1245                                              Offset(struct lit_info, func)));
1246    }
1247    else {
1248       x86_mov_reg_imm( cp->func, ecx, (int)aos_do_lit );
1249    }
1250
1251    x86_call( cp->func, ecx );
1252
1253    x86_pop( cp->func, ecx );    /* fixme... */
1254    x86_pop( cp->func, ecx );
1255    x86_pop( cp->func, ecx );
1256    x86_pop( cp->func, ecx );
1257
1258    x86_cdecl_caller_pop_regs( cp->func );
1259
1260    if (writemask != TGSI_WRITEMASK_XYZW) {
1261       store_dest( cp,
1262                   &op->Dst[0],
1263                   get_xmm_writable( cp, result ) );
1264    }
1265
1266    return TRUE;
1267 }
1268
1269 #if 0
1270 static boolean emit_inline_LIT( struct aos_compilation *cp, const struct tgsi_full_instruction *op )
1271 {
1272    struct x86_reg dst = get_dst_ptr(cp, &op->Dst[0]);
1273    unsigned writemask = op->Dst[0].Register.WriteMask;
1274
1275    if (writemask & TGSI_WRITEMASK_YZ) {
1276       struct x86_reg st1 = x86_make_reg(file_x87, 1);
1277       struct x86_reg st2 = x86_make_reg(file_x87, 2);
1278
1279       /* a1' = a1 <= 0 ? 1 : a1;
1280        */
1281       x87_fldz(cp->func);                           /* 1 0  */
1282 #if 1
1283       x87_fld1(cp->func);                           /* 1 0  */
1284 #else
1285       /* Correct but slow due to fp exceptions generated in fyl2x - fix me.
1286        */
1287       x87_fldz(cp->func);                           /* 1 0  */
1288 #endif
1289       x87_fld_src(cp, &op->Src[0], 1); /* a1 1 0  */
1290       x87_fcomi(cp->func, st2);                     /* a1 1 0  */
1291       x87_fcmovb(cp->func, st1);                    /* a1' 1 0  */
1292       x87_fstp(cp->func, st1);                      /* a1' 0  */
1293       x87_fstp(cp->func, st1);                      /* a1'  */
1294
1295       x87_fld_src(cp, &op->Src[0], 3); /* a3 a1'  */
1296       x87_fxch(cp->func, st1);                      /* a1' a3  */
1297
1298
1299       /* Compute pow(a1, a3)
1300        */
1301       x87_fyl2x(cp->func);      /* a3*log2(a1)      */
1302       x87_emit_ex2( cp );       /* 2^(a3*log2(a1))   */
1303
1304
1305       /* a0' = max2(a0, 0):
1306        */
1307       x87_fldz(cp->func);                           /* 0 r2 */
1308       x87_fld_src(cp, &op->Src[0], 0); /* a0 0 r2 */
1309       x87_fcomi(cp->func, st1);
1310       x87_fcmovb(cp->func, st1);                    /* a0' 0 r2 */
1311
1312       x87_fst_or_nop(cp->func, writemask, 1, dst); /* result[1] = a0' */
1313
1314       x87_fcomi(cp->func, st1);  /* a0' 0 r2 */
1315       x87_fcmovnbe(cp->func, st2); /* r2' 0' r2 */
1316
1317       x87_fstp_or_pop(cp->func, writemask, 2, dst); /* 0 r2 */
1318       x87_fpop(cp->func);       /* r2 */
1319       x87_fpop(cp->func);
1320    }
1321
1322    if (writemask & TGSI_WRITEMASK_XW) {
1323       x87_fld1(cp->func);
1324       x87_fst_or_nop(cp->func, writemask, 0, dst);
1325       x87_fstp_or_pop(cp->func, writemask, 3, dst);
1326    }
1327
1328    return TRUE;
1329 }
1330 #endif
1331
1332
1333
1334 static boolean emit_MAX( struct aos_compilation *cp, const struct tgsi_full_instruction *op )
1335 {
1336    struct x86_reg arg0 = fetch_src(cp, &op->Src[0]);
1337    struct x86_reg arg1 = fetch_src(cp, &op->Src[1]);
1338    struct x86_reg dst = get_xmm_writable(cp, arg0);
1339
1340    sse_maxps(cp->func, dst, arg1);
1341
1342    store_dest(cp, &op->Dst[0], dst);
1343    return TRUE;
1344 }
1345
1346
1347 static boolean emit_MIN( struct aos_compilation *cp, const struct tgsi_full_instruction *op )
1348 {
1349    struct x86_reg arg0 = fetch_src(cp, &op->Src[0]);
1350    struct x86_reg arg1 = fetch_src(cp, &op->Src[1]);
1351    struct x86_reg dst = get_xmm_writable(cp, arg0);
1352
1353    sse_minps(cp->func, dst, arg1);
1354
1355    store_dest(cp, &op->Dst[0], dst);
1356    return TRUE;
1357 }
1358
1359 static boolean emit_MOV( struct aos_compilation *cp, const struct tgsi_full_instruction *op )
1360 {
1361    struct x86_reg arg0 = fetch_src(cp, &op->Src[0]);
1362    struct x86_reg dst = get_xmm_writable(cp, arg0);
1363
1364    /* potentially nothing to do */
1365
1366    store_dest(cp, &op->Dst[0], dst);
1367    return TRUE;
1368 }
1369
1370 static boolean emit_MUL( struct aos_compilation *cp, const struct tgsi_full_instruction *op )
1371 {
1372    struct x86_reg arg0 = fetch_src(cp, &op->Src[0]);
1373    struct x86_reg arg1 = fetch_src(cp, &op->Src[1]);
1374    struct x86_reg dst = get_xmm_writable(cp, arg0);
1375
1376    sse_mulps(cp->func, dst, arg1);
1377
1378    store_dest(cp, &op->Dst[0], dst);
1379    return TRUE;
1380 }
1381
1382
1383 static boolean emit_MAD( struct aos_compilation *cp, const struct tgsi_full_instruction *op )
1384 {
1385    struct x86_reg arg0 = fetch_src(cp, &op->Src[0]);
1386    struct x86_reg arg1 = fetch_src(cp, &op->Src[1]);
1387    struct x86_reg arg2 = fetch_src(cp, &op->Src[2]);
1388
1389    /* If we can't clobber old contents of arg0, get a temporary & copy
1390     * it there, then clobber it...
1391     */
1392    arg0 = get_xmm_writable(cp, arg0);
1393
1394    sse_mulps(cp->func, arg0, arg1);
1395    sse_addps(cp->func, arg0, arg2);
1396    store_dest(cp, &op->Dst[0], arg0);
1397    return TRUE;
1398 }
1399
1400
1401
1402 /* A wrapper for powf().
1403  * Makes sure it is cdecl and operates on floats.
1404  */
1405 static float PIPE_CDECL _powerf( float x, float y )
1406 {
1407 #if FAST_MATH
1408    return util_fast_pow(x, y);
1409 #else
1410    return powf( x, y );
1411 #endif
1412 }
1413
1414 #if FAST_MATH
1415 static float PIPE_CDECL _exp2(float x)
1416 {
1417    return util_fast_exp2(x);
1418 }
1419 #endif
1420
1421
1422 /* Really not sufficient -- need to check for conditions that could
1423  * generate inf/nan values, which will slow things down hugely.
1424  */
1425 static boolean emit_POW( struct aos_compilation *cp, const struct tgsi_full_instruction *op )
1426 {
1427 #if 0
1428    x87_fld_src(cp, &op->Src[1], 0);  /* a1.x */
1429    x87_fld_src(cp, &op->Src[0], 0);     /* a0.x a1.x */
1430    x87_fyl2x(cp->func);                                 /* a1*log2(a0) */
1431
1432    x87_emit_ex2( cp );          /* 2^(a1*log2(a0)) */
1433
1434    x87_fstp_dest4(cp, &op->Dst[0]);
1435 #else
1436    uint i;
1437
1438    /* For absolute correctness, need to spill/invalidate all XMM regs
1439     * too.
1440     */
1441    for (i = 0; i < 8; i++) {
1442       if (cp->xmm[i].dirty)
1443          spill(cp, i);
1444       aos_release_xmm_reg(cp, i);
1445    }
1446
1447    /* Push caller-save (ie scratch) regs.
1448     */
1449    x86_cdecl_caller_push_regs( cp->func );
1450
1451    x86_lea( cp->func, cp->stack_ESP, x86_make_disp(cp->stack_ESP, -8) );
1452
1453    x87_fld_src( cp, &op->Src[1], 0 );
1454    x87_fstp( cp->func, x86_make_disp( cp->stack_ESP, 4 ) );
1455    x87_fld_src( cp, &op->Src[0], 0 );
1456    x87_fstp( cp->func, x86_make_disp( cp->stack_ESP, 0 ) );
1457
1458    /* tmp_EAX has been pushed & will be restored below */
1459    x86_mov_reg_imm( cp->func, cp->tmp_EAX, (unsigned long) _powerf );
1460    x86_call( cp->func, cp->tmp_EAX );
1461
1462    x86_lea( cp->func, cp->stack_ESP, x86_make_disp(cp->stack_ESP, 8) );
1463
1464    x86_cdecl_caller_pop_regs( cp->func );
1465
1466    /* Note retval on x87 stack:
1467     */
1468    cp->func->x87_stack++;
1469
1470    x87_fstp_dest4( cp, &op->Dst[0] );
1471 #endif
1472    return TRUE;
1473 }
1474
1475
1476 #if FAST_MATH
1477 static boolean emit_EXPBASE2( struct aos_compilation *cp, const struct tgsi_full_instruction *op )
1478 {
1479    uint i;
1480
1481    /* For absolute correctness, need to spill/invalidate all XMM regs
1482     * too.
1483     */
1484    for (i = 0; i < 8; i++) {
1485       if (cp->xmm[i].dirty)
1486          spill(cp, i);
1487       aos_release_xmm_reg(cp, i);
1488    }
1489
1490    /* Push caller-save (ie scratch) regs.
1491     */
1492    x86_cdecl_caller_push_regs( cp->func );
1493
1494    x86_lea( cp->func, cp->stack_ESP, x86_make_disp(cp->stack_ESP, -4) );
1495
1496    x87_fld_src( cp, &op->Src[0], 0 );
1497    x87_fstp( cp->func, x86_make_disp( cp->stack_ESP, 0 ) );
1498
1499    /* tmp_EAX has been pushed & will be restored below */
1500    x86_mov_reg_imm( cp->func, cp->tmp_EAX, (unsigned long) _exp2 );
1501    x86_call( cp->func, cp->tmp_EAX );
1502
1503    x86_lea( cp->func, cp->stack_ESP, x86_make_disp(cp->stack_ESP, 4) );
1504
1505    x86_cdecl_caller_pop_regs( cp->func );
1506
1507    /* Note retval on x87 stack:
1508     */
1509    cp->func->x87_stack++;
1510
1511    x87_fstp_dest4( cp, &op->Dst[0] );
1512
1513    return TRUE;
1514 }
1515 #endif
1516
1517
1518 static boolean emit_RCP( struct aos_compilation *cp, const struct tgsi_full_instruction *op )
1519 {
1520    struct x86_reg arg0 = fetch_src(cp, &op->Src[0]);
1521    struct x86_reg dst = aos_get_xmm_reg(cp);
1522
1523    if (cp->have_sse2) {
1524       sse2_rcpss(cp->func, dst, arg0);
1525       /* extend precision here...
1526        */
1527    }
1528    else {
1529       struct x86_reg ones = aos_get_internal(cp, IMM_ONES);
1530       sse_movss(cp->func, dst, ones);
1531       sse_divss(cp->func, dst, arg0);
1532    }
1533
1534    store_scalar_dest(cp, &op->Dst[0], dst);
1535    return TRUE;
1536 }
1537
1538
1539 /* Although rsqrtps() and rcpps() are low precision on some/all SSE
1540  * implementations, it is possible to improve its precision at
1541  * fairly low cost, using a newton/raphson step, as below:
1542  *
1543  * x1 = 2 * rcpps(a) - a * rcpps(a) * rcpps(a)
1544  * x1 = 0.5 * rsqrtps(a) * [3.0 - (a * rsqrtps(a))* rsqrtps(a)]
1545  * or:
1546  *   x1 = rsqrtps(a) * [1.5 - .5 * a * rsqrtps(a) * rsqrtps(a)]
1547  *
1548  *
1549  * See: http://softwarecommunity.intel.com/articles/eng/1818.htm
1550  */
1551 static boolean emit_RSQ( struct aos_compilation *cp, const struct tgsi_full_instruction *op )
1552 {
1553    if (0) {
1554       struct x86_reg arg0 = fetch_src(cp, &op->Src[0]);
1555       struct x86_reg r = aos_get_xmm_reg(cp);
1556       sse_rsqrtss(cp->func, r, arg0);
1557       store_scalar_dest(cp, &op->Dst[0], r);
1558       return TRUE;
1559    }
1560    else {
1561       struct x86_reg arg0           = fetch_src(cp, &op->Src[0]);
1562       struct x86_reg r              = aos_get_xmm_reg(cp);
1563
1564       struct x86_reg neg_half       = get_reg_ptr( cp, AOS_FILE_INTERNAL, IMM_RSQ );
1565       struct x86_reg one_point_five = x86_make_disp( neg_half, 4 );
1566       struct x86_reg src            = get_xmm_writable( cp, arg0 );
1567       struct x86_reg neg            = aos_get_internal(cp, IMM_NEGS);
1568       struct x86_reg tmp            = aos_get_xmm_reg(cp);
1569
1570       sse_movaps(cp->func, tmp, src);
1571       sse_mulps(cp->func, tmp, neg);
1572       sse_maxps(cp->func, tmp, src);
1573
1574       sse_rsqrtss( cp->func, r, tmp  );             /* rsqrtss(a) */
1575       sse_mulss(   cp->func, tmp, neg_half  );      /* -.5 * a */
1576       sse_mulss(   cp->func, tmp,  r );             /* -.5 * a * r */
1577       sse_mulss(   cp->func, tmp,  r );             /* -.5 * a * r * r */
1578       sse_addss(   cp->func, tmp, one_point_five ); /* 1.5 - .5 * a * r * r */
1579       sse_mulss(   cp->func, r,  tmp );             /* r * (1.5 - .5 * a * r * r) */
1580
1581       store_scalar_dest(cp, &op->Dst[0], r);
1582
1583       aos_release_xmm_reg(cp, tmp.idx);
1584
1585       return TRUE;
1586    }
1587 }
1588
1589
1590 static boolean emit_SGE( struct aos_compilation *cp, const struct tgsi_full_instruction *op )
1591 {
1592    struct x86_reg arg0 = fetch_src(cp, &op->Src[0]);
1593    struct x86_reg arg1 = fetch_src(cp, &op->Src[1]);
1594    struct x86_reg ones = aos_get_internal(cp, IMM_ONES);
1595    struct x86_reg dst = get_xmm_writable(cp, arg0);
1596
1597    sse_cmpps(cp->func, dst, arg1, cc_NotLessThan);
1598    sse_andps(cp->func, dst, ones);
1599
1600    store_dest(cp, &op->Dst[0], dst);
1601    return TRUE;
1602 }
1603
1604 static boolean emit_SIN( struct aos_compilation *cp, const struct tgsi_full_instruction *op )
1605 {
1606    x87_fld_src(cp, &op->Src[0], 0);
1607    x87_fsin(cp->func);
1608    x87_fstp_dest4(cp, &op->Dst[0]);
1609    return TRUE;
1610 }
1611
1612
1613
1614 static boolean emit_SLT( struct aos_compilation *cp, const struct tgsi_full_instruction *op )
1615 {
1616    struct x86_reg arg0 = fetch_src(cp, &op->Src[0]);
1617    struct x86_reg arg1 = fetch_src(cp, &op->Src[1]);
1618    struct x86_reg ones = aos_get_internal(cp, IMM_ONES);
1619    struct x86_reg dst = get_xmm_writable(cp, arg0);
1620
1621    sse_cmpps(cp->func, dst, arg1, cc_LessThan);
1622    sse_andps(cp->func, dst, ones);
1623
1624    store_dest(cp, &op->Dst[0], dst);
1625    return TRUE;
1626 }
1627
1628 static boolean emit_SUB( struct aos_compilation *cp, const struct tgsi_full_instruction *op )
1629 {
1630    struct x86_reg arg0 = fetch_src(cp, &op->Src[0]);
1631    struct x86_reg arg1 = fetch_src(cp, &op->Src[1]);
1632    struct x86_reg dst = get_xmm_writable(cp, arg0);
1633
1634    sse_subps(cp->func, dst, arg1);
1635
1636    store_dest(cp, &op->Dst[0], dst);
1637    return TRUE;
1638 }
1639
1640 static boolean emit_TRUNC( struct aos_compilation *cp, const struct tgsi_full_instruction *op )
1641 {
1642    struct x86_reg arg0 = fetch_src(cp, &op->Src[0]);
1643    struct x86_reg tmp0 = aos_get_xmm_reg(cp);
1644
1645    sse2_cvttps2dq(cp->func, tmp0, arg0);
1646    sse2_cvtdq2ps(cp->func, tmp0, tmp0);
1647
1648    store_dest(cp, &op->Dst[0], tmp0);
1649    return TRUE;
1650 }
1651
1652 static boolean emit_XPD( struct aos_compilation *cp, const struct tgsi_full_instruction *op )
1653 {
1654    struct x86_reg arg0 = fetch_src(cp, &op->Src[0]);
1655    struct x86_reg arg1 = fetch_src(cp, &op->Src[1]);
1656    struct x86_reg tmp0 = aos_get_xmm_reg(cp);
1657    struct x86_reg tmp1 = aos_get_xmm_reg(cp);
1658
1659    emit_pshufd(cp, tmp1, arg1, SHUF(Y, Z, X, W));
1660    sse_mulps(cp->func, tmp1, arg0);
1661    emit_pshufd(cp, tmp0, arg0, SHUF(Y, Z, X, W));
1662    sse_mulps(cp->func, tmp0, arg1);
1663    sse_subps(cp->func, tmp1, tmp0);
1664    sse_shufps(cp->func, tmp1, tmp1, SHUF(Y, Z, X, W));
1665
1666 /*    dst[2] = arg0[0] * arg1[1] - arg0[1] * arg1[0]; */
1667 /*    dst[0] = arg0[1] * arg1[2] - arg0[2] * arg1[1]; */
1668 /*    dst[1] = arg0[2] * arg1[0] - arg0[0] * arg1[2]; */
1669 /*    dst[3] is undef */
1670
1671
1672    aos_release_xmm_reg(cp, tmp0.idx);
1673    store_dest(cp, &op->Dst[0], tmp1);
1674    return TRUE;
1675 }
1676
1677
1678
1679 static boolean
1680 emit_instruction( struct aos_compilation *cp,
1681                   struct tgsi_full_instruction *inst )
1682 {
1683    x87_assert_stack_empty(cp->func);
1684
1685    switch( inst->Instruction.Opcode ) {
1686    case TGSI_OPCODE_MOV:
1687       return emit_MOV( cp, inst );
1688
1689    case TGSI_OPCODE_LIT:
1690       return emit_LIT(cp, inst);
1691
1692    case TGSI_OPCODE_RCP:
1693       return emit_RCP(cp, inst);
1694
1695    case TGSI_OPCODE_RSQ:
1696       return emit_RSQ(cp, inst);
1697
1698    case TGSI_OPCODE_EXP:
1699       /*return emit_EXP(cp, inst);*/
1700       return FALSE;
1701
1702    case TGSI_OPCODE_LOG:
1703       /*return emit_LOG(cp, inst);*/
1704       return FALSE;
1705
1706    case TGSI_OPCODE_MUL:
1707       return emit_MUL(cp, inst);
1708
1709    case TGSI_OPCODE_ADD:
1710       return emit_ADD(cp, inst);
1711
1712    case TGSI_OPCODE_DP3:
1713       return emit_DP3(cp, inst);
1714
1715    case TGSI_OPCODE_DP4:
1716       return emit_DP4(cp, inst);
1717
1718    case TGSI_OPCODE_DST:
1719       return emit_DST(cp, inst);
1720
1721    case TGSI_OPCODE_MIN:
1722       return emit_MIN(cp, inst);
1723
1724    case TGSI_OPCODE_MAX:
1725       return emit_MAX(cp, inst);
1726
1727    case TGSI_OPCODE_SLT:
1728       return emit_SLT(cp, inst);
1729
1730    case TGSI_OPCODE_SGE:
1731       return emit_SGE(cp, inst);
1732
1733    case TGSI_OPCODE_MAD:
1734       return emit_MAD(cp, inst);
1735
1736    case TGSI_OPCODE_SUB:
1737       return emit_SUB(cp, inst);
1738
1739    case TGSI_OPCODE_LRP:
1740       /*return emit_LERP(cp, inst);*/
1741       return FALSE;
1742
1743    case TGSI_OPCODE_FRC:
1744       return emit_FRC(cp, inst);
1745
1746    case TGSI_OPCODE_CLAMP:
1747       /*return emit_CLAMP(cp, inst);*/
1748       return FALSE;
1749
1750    case TGSI_OPCODE_FLR:
1751       return emit_FLR(cp, inst);
1752
1753    case TGSI_OPCODE_ROUND:
1754       return emit_RND(cp, inst);
1755
1756    case TGSI_OPCODE_EX2:
1757 #if FAST_MATH
1758       return emit_EXPBASE2(cp, inst);
1759 #elif 0
1760       /* this seems to fail for "larger" exponents.
1761        * See glean tvertProg1's EX2 test.
1762        */
1763       return emit_EX2(cp, inst);
1764 #else
1765       return FALSE;
1766 #endif
1767
1768    case TGSI_OPCODE_LG2:
1769       return emit_LG2(cp, inst);
1770
1771    case TGSI_OPCODE_POW:
1772       return emit_POW(cp, inst);
1773
1774    case TGSI_OPCODE_XPD:
1775       return emit_XPD(cp, inst);
1776
1777    case TGSI_OPCODE_ABS:
1778       return emit_ABS(cp, inst);
1779
1780    case TGSI_OPCODE_DPH:
1781       return emit_DPH(cp, inst);
1782
1783    case TGSI_OPCODE_COS:
1784       return emit_COS(cp, inst);
1785
1786    case TGSI_OPCODE_SIN:
1787       return emit_SIN(cp, inst);
1788
1789    case TGSI_OPCODE_TRUNC:
1790       return emit_TRUNC(cp, inst);
1791
1792    case TGSI_OPCODE_END:
1793       return TRUE;
1794
1795    default:
1796       return FALSE;
1797    }
1798 }
1799
1800
1801 static boolean emit_viewport( struct aos_compilation *cp )
1802 {
1803    struct x86_reg pos = aos_get_shader_reg_xmm(cp,
1804                                                TGSI_FILE_OUTPUT,
1805                                                cp->vaos->draw->vs.position_output );
1806
1807    struct x86_reg scale = x86_make_disp(cp->machine_EDX,
1808                                         Offset(struct aos_machine, scale));
1809
1810    struct x86_reg translate = x86_make_disp(cp->machine_EDX,
1811                                         Offset(struct aos_machine, translate));
1812
1813    sse_mulps(cp->func, pos, scale);
1814    sse_addps(cp->func, pos, translate);
1815
1816    aos_adopt_xmm_reg( cp,
1817                       pos,
1818                       TGSI_FILE_OUTPUT,
1819                       cp->vaos->draw->vs.position_output,
1820                       TRUE );
1821    return TRUE;
1822 }
1823
1824
1825 /* This is useful to be able to see the results on softpipe.  Doesn't
1826  * do proper clipping, just assumes the backend can do it during
1827  * rasterization -- for debug only...
1828  */
1829 static boolean emit_rhw_viewport( struct aos_compilation *cp )
1830 {
1831    struct x86_reg tmp = aos_get_xmm_reg(cp);
1832    struct x86_reg pos = aos_get_shader_reg_xmm(cp,
1833                                                TGSI_FILE_OUTPUT,
1834                                                cp->vaos->draw->vs.position_output);
1835
1836    struct x86_reg scale = x86_make_disp(cp->machine_EDX,
1837                                         Offset(struct aos_machine, scale));
1838
1839    struct x86_reg translate = x86_make_disp(cp->machine_EDX,
1840                                         Offset(struct aos_machine, translate));
1841
1842
1843
1844    emit_pshufd(cp, tmp, pos, SHUF(W, W, W, W));
1845    sse2_rcpss(cp->func, tmp, tmp);
1846    sse_shufps(cp->func, tmp, tmp, SHUF(X, X, X, X));
1847
1848    sse_mulps(cp->func, pos, scale);
1849    sse_mulps(cp->func, pos, tmp);
1850    sse_addps(cp->func, pos, translate);
1851
1852    /* Set pos[3] = w
1853     */
1854    mask_write(cp, pos, tmp, TGSI_WRITEMASK_W);
1855
1856    aos_adopt_xmm_reg( cp,
1857                       pos,
1858                       TGSI_FILE_OUTPUT,
1859                       cp->vaos->draw->vs.position_output,
1860                       TRUE );
1861    return TRUE;
1862 }
1863
1864
1865 #if 0
1866 static boolean note_immediate( struct aos_compilation *cp,
1867                                struct tgsi_full_immediate *imm )
1868 {
1869    unsigned pos = cp->num_immediates++;
1870    unsigned j;
1871
1872    assert( imm->Immediate.NrTokens <= 4 + 1 );
1873    for (j = 0; j < imm->Immediate.NrTokens - 1; j++) {
1874       cp->vaos->machine->immediate[pos][j] = imm->u[j].Float;
1875    }
1876
1877    return TRUE;
1878 }
1879 #endif
1880
1881
1882
1883
1884 static void find_last_write_outputs( struct aos_compilation *cp )
1885 {
1886    struct tgsi_parse_context parse;
1887    unsigned this_instruction = 0;
1888    unsigned i;
1889
1890    tgsi_parse_init( &parse, cp->vaos->base.vs->state.tokens );
1891
1892    while (!tgsi_parse_end_of_tokens( &parse )) {
1893
1894       tgsi_parse_token( &parse );
1895
1896       if (parse.FullToken.Token.Type != TGSI_TOKEN_TYPE_INSTRUCTION)
1897          continue;
1898
1899       for (i = 0; i < TGSI_FULL_MAX_DST_REGISTERS; i++) {
1900          if (parse.FullToken.FullInstruction.Dst[i].Register.File ==
1901              TGSI_FILE_OUTPUT)
1902          {
1903             unsigned idx = parse.FullToken.FullInstruction.Dst[i].Register.Index;
1904             cp->output_last_write[idx] = this_instruction;
1905          }
1906       }
1907
1908       this_instruction++;
1909    }
1910
1911    tgsi_parse_free( &parse );
1912 }
1913
1914
1915 #define ARG_MACHINE    1
1916 #define ARG_START_ELTS 2
1917 #define ARG_COUNT      3
1918 #define ARG_OUTBUF     4
1919
1920
1921 static boolean build_vertex_program( struct draw_vs_variant_aos_sse *variant,
1922                                      boolean linear )
1923 {
1924    struct tgsi_parse_context parse;
1925    struct aos_compilation cp;
1926    unsigned fixup, label;
1927
1928    util_init_math();
1929
1930    tgsi_parse_init( &parse, variant->base.vs->state.tokens );
1931
1932    memset(&cp, 0, sizeof(cp));
1933
1934    cp.insn_counter = 1;
1935    cp.vaos = variant;
1936    cp.have_sse2 = 1;
1937    cp.func = &variant->func[ linear ? 0 : 1 ];
1938
1939    cp.tmp_EAX       = x86_make_reg(file_REG32, reg_AX);
1940    cp.idx_EBX      = x86_make_reg(file_REG32, reg_BX);
1941    cp.outbuf_ECX    = x86_make_reg(file_REG32, reg_CX);
1942    cp.machine_EDX   = x86_make_reg(file_REG32, reg_DX);
1943    cp.count_ESI     = x86_make_reg(file_REG32, reg_SI);
1944    cp.temp_EBP     = x86_make_reg(file_REG32, reg_BP);
1945    cp.stack_ESP = x86_make_reg( file_REG32, reg_SP );
1946
1947    x86_init_func(cp.func);
1948
1949    find_last_write_outputs(&cp);
1950
1951    x86_push(cp.func, cp.idx_EBX);
1952    x86_push(cp.func, cp.count_ESI);
1953    x86_push(cp.func, cp.temp_EBP);
1954
1955
1956    /* Load arguments into regs:
1957     */
1958    x86_mov(cp.func, cp.machine_EDX, x86_fn_arg(cp.func, ARG_MACHINE));
1959    x86_mov(cp.func, cp.idx_EBX, x86_fn_arg(cp.func, ARG_START_ELTS));
1960    x86_mov(cp.func, cp.count_ESI, x86_fn_arg(cp.func, ARG_COUNT));
1961    x86_mov(cp.func, cp.outbuf_ECX, x86_fn_arg(cp.func, ARG_OUTBUF));
1962
1963
1964    /* Compare count to zero and possibly bail.
1965     */
1966    x86_xor(cp.func, cp.tmp_EAX, cp.tmp_EAX);
1967    x86_cmp(cp.func, cp.count_ESI, cp.tmp_EAX);
1968    fixup = x86_jcc_forward(cp.func, cc_E);
1969
1970
1971    save_fpu_state( &cp );
1972    set_fpu_round_nearest( &cp );
1973
1974    aos_init_inputs( &cp, linear );
1975
1976    cp.x86_reg[0] = 0;
1977    cp.x86_reg[1] = 0;
1978
1979    /* Note address for loop jump
1980     */
1981    label = x86_get_label(cp.func);
1982    {
1983       /* Fetch inputs...  TODO:  fetch lazily...
1984        */
1985       if (!aos_fetch_inputs( &cp, linear ))
1986          goto fail;
1987
1988       /* Emit the shader:
1989        */
1990       while( !tgsi_parse_end_of_tokens( &parse ) && !cp.error )
1991       {
1992          tgsi_parse_token( &parse );
1993
1994          switch (parse.FullToken.Token.Type) {
1995          case TGSI_TOKEN_TYPE_IMMEDIATE:
1996 #if 0
1997             if (!note_immediate( &cp, &parse.FullToken.FullImmediate ))
1998                goto fail;
1999 #endif
2000             break;
2001
2002          case TGSI_TOKEN_TYPE_INSTRUCTION:
2003             if (DISASSEM)
2004                tgsi_dump_instruction( &parse.FullToken.FullInstruction, cp.insn_counter );
2005
2006             if (!emit_instruction( &cp, &parse.FullToken.FullInstruction ))
2007                goto fail;
2008             break;
2009          }
2010
2011          x87_assert_stack_empty(cp.func);
2012          cp.insn_counter++;
2013
2014          if (DISASSEM)
2015             debug_printf("\n");
2016       }
2017
2018
2019       {
2020          unsigned i;
2021          for (i = 0; i < 8; i++) {
2022             if (cp.xmm[i].file != TGSI_FILE_OUTPUT) {
2023                cp.xmm[i].file = TGSI_FILE_NULL;
2024                cp.xmm[i].dirty = 0;
2025             }
2026          }
2027       }
2028
2029       if (cp.error)
2030          goto fail;
2031
2032       if (cp.vaos->base.key.clip) {
2033          /* not really handling clipping, just do the rhw so we can
2034           * see the results...
2035           */
2036          emit_rhw_viewport(&cp);
2037       }
2038       else if (cp.vaos->base.key.viewport) {
2039          emit_viewport(&cp);
2040       }
2041
2042       /* Emit output...  TODO: do this eagerly after the last write to a
2043        * given output.
2044        */
2045       if (!aos_emit_outputs( &cp ))
2046          goto fail;
2047
2048
2049       /* Next vertex:
2050        */
2051       x86_lea(cp.func,
2052               cp.outbuf_ECX,
2053               x86_make_disp(cp.outbuf_ECX,
2054                             cp.vaos->base.key.output_stride));
2055
2056       /* Incr index
2057        */
2058       aos_incr_inputs( &cp, linear );
2059    }
2060    /* decr count, loop if not zero
2061     */
2062    x86_dec(cp.func, cp.count_ESI);
2063    x86_jcc(cp.func, cc_NZ, label);
2064
2065    restore_fpu_state(&cp);
2066
2067    /* Land forward jump here:
2068     */
2069    x86_fixup_fwd_jump(cp.func, fixup);
2070
2071    /* Exit mmx state?
2072     */
2073    if (cp.func->need_emms)
2074       mmx_emms(cp.func);
2075
2076    x86_pop(cp.func, cp.temp_EBP);
2077    x86_pop(cp.func, cp.count_ESI);
2078    x86_pop(cp.func, cp.idx_EBX);
2079
2080    x87_assert_stack_empty(cp.func);
2081    x86_ret(cp.func);
2082
2083    tgsi_parse_free( &parse );
2084    return !cp.error;
2085
2086  fail:
2087    tgsi_parse_free( &parse );
2088    return FALSE;
2089 }
2090
2091
2092 /** cast wrapper */
2093 static INLINE struct draw_vs_variant_aos_sse *
2094 draw_vs_variant_aos_sse(struct draw_vs_variant *variant)
2095 {
2096    return (struct draw_vs_variant_aos_sse *) variant;
2097 }
2098
2099
2100 static void vaos_set_buffer( struct draw_vs_variant *variant,
2101                              unsigned buf,
2102                              const void *ptr,
2103                              unsigned stride,
2104                              unsigned max_stride)
2105 {
2106    struct draw_vs_variant_aos_sse *vaos = draw_vs_variant_aos_sse(variant);
2107
2108    if (buf < vaos->nr_vb) {
2109       vaos->buffer[buf].base_ptr = (char *)ptr;
2110       vaos->buffer[buf].stride = stride;
2111    }
2112
2113    if (0) debug_printf("%s %d/%d: %p %d\n", __FUNCTION__, buf, vaos->nr_vb, ptr, stride);
2114 }
2115
2116
2117
2118 static void PIPE_CDECL vaos_run_elts( struct draw_vs_variant *variant,
2119                                       const unsigned *elts,
2120                                       unsigned count,
2121                                       void *output_buffer )
2122 {
2123    struct draw_vs_variant_aos_sse *vaos = draw_vs_variant_aos_sse(variant);
2124    struct aos_machine *machine = vaos->draw->vs.aos_machine;
2125    unsigned i;
2126
2127    if (0) debug_printf("%s %d\n", __FUNCTION__, count);
2128
2129    machine->internal[IMM_PSIZE][0] = vaos->draw->rasterizer->point_size;
2130    for (i = 0; i < PIPE_MAX_CONSTANT_BUFFERS; i++) {
2131       machine->constants[i] = vaos->draw->vs.aligned_constants[i];
2132    }
2133    machine->immediates = vaos->base.vs->immediates;
2134    machine->buffer = vaos->buffer;
2135
2136    vaos->gen_run_elts( machine,
2137                        elts,
2138                        count,
2139                        output_buffer );
2140 }
2141
2142 static void PIPE_CDECL vaos_run_linear( struct draw_vs_variant *variant,
2143                                         unsigned start,
2144                                         unsigned count,
2145                                         void *output_buffer )
2146 {
2147    struct draw_vs_variant_aos_sse *vaos = draw_vs_variant_aos_sse(variant);
2148    struct aos_machine *machine = vaos->draw->vs.aos_machine;
2149    unsigned i;
2150
2151    if (0) debug_printf("%s %d %d const: %x\n", __FUNCTION__, start, count,
2152                        vaos->base.key.const_vbuffers);
2153
2154    machine->internal[IMM_PSIZE][0] = vaos->draw->rasterizer->point_size;
2155    for (i = 0; i < PIPE_MAX_CONSTANT_BUFFERS; i++) {
2156       machine->constants[i] = vaos->draw->vs.aligned_constants[i];
2157    }
2158    machine->immediates = vaos->base.vs->immediates;
2159    machine->buffer = vaos->buffer;
2160
2161    vaos->gen_run_linear( machine,
2162                          start,
2163                          count,
2164                          output_buffer );
2165
2166    /* Sanity spot checks to make sure we didn't trash our constants */
2167    assert(machine->internal[IMM_ONES][0] == 1.0f);
2168    assert(machine->internal[IMM_IDENTITY][0] == 0.0f);
2169    assert(machine->internal[IMM_NEGS][0] == -1.0f);
2170 }
2171
2172
2173
2174 static void vaos_destroy( struct draw_vs_variant *variant )
2175 {
2176    struct draw_vs_variant_aos_sse *vaos = draw_vs_variant_aos_sse(variant);
2177
2178    FREE( vaos->buffer );
2179
2180    x86_release_func( &vaos->func[0] );
2181    x86_release_func( &vaos->func[1] );
2182
2183    FREE(vaos);
2184 }
2185
2186
2187
2188 static struct draw_vs_variant *variant_aos_sse( struct draw_vertex_shader *vs,
2189                                                  const struct draw_vs_variant_key *key )
2190 {
2191    unsigned i;
2192    struct draw_vs_variant_aos_sse *vaos = CALLOC_STRUCT(draw_vs_variant_aos_sse);
2193
2194    if (!vaos)
2195       goto fail;
2196
2197    vaos->base.key = *key;
2198    vaos->base.vs = vs;
2199    vaos->base.set_buffer = vaos_set_buffer;
2200    vaos->base.destroy = vaos_destroy;
2201    vaos->base.run_linear = vaos_run_linear;
2202    vaos->base.run_elts = vaos_run_elts;
2203
2204    vaos->draw = vs->draw;
2205
2206    for (i = 0; i < key->nr_inputs; i++)
2207       vaos->nr_vb = MAX2( vaos->nr_vb, key->element[i].in.buffer + 1 );
2208
2209    vaos->buffer = MALLOC( vaos->nr_vb * sizeof(vaos->buffer[0]) );
2210    if (!vaos->buffer)
2211       goto fail;
2212
2213    if (0)
2214       debug_printf("nr_vb: %d const: %x\n", vaos->nr_vb, vaos->base.key.const_vbuffers);
2215
2216 #if 0
2217    tgsi_dump(vs->state.tokens, 0);
2218 #endif
2219
2220    if (!build_vertex_program( vaos, TRUE ))
2221       goto fail;
2222
2223    if (!build_vertex_program( vaos, FALSE ))
2224       goto fail;
2225
2226    vaos->gen_run_linear = (vaos_run_linear_func)x86_get_func(&vaos->func[0]);
2227    if (!vaos->gen_run_linear)
2228       goto fail;
2229
2230    vaos->gen_run_elts = (vaos_run_elts_func)x86_get_func(&vaos->func[1]);
2231    if (!vaos->gen_run_elts)
2232       goto fail;
2233
2234    return &vaos->base;
2235
2236  fail:
2237    if (vaos && vaos->buffer)
2238       FREE(vaos->buffer);
2239
2240    if (vaos)
2241       x86_release_func( &vaos->func[0] );
2242
2243    if (vaos)
2244       x86_release_func( &vaos->func[1] );
2245
2246    FREE(vaos);
2247
2248    return NULL;
2249 }
2250
2251
2252 struct draw_vs_variant *
2253 draw_vs_create_variant_aos_sse( struct draw_vertex_shader *vs,
2254                                 const struct draw_vs_variant_key *key )
2255 {
2256    struct draw_vs_variant *variant = variant_aos_sse( vs, key );
2257
2258    if (variant == NULL) {
2259       variant = draw_vs_create_variant_generic( vs, key );
2260    }
2261
2262    return variant;
2263 }
2264
2265
2266
2267 #endif /* PIPE_ARCH_X86 */