src/mesa/x86/rtasm/x86sse.c

   1 #ifdef USE_X86_ASM
   2 #if defined(__i386__) || defined(__386__)
   3
   4 #include <stdio.h>
   5
   6 #include "main/imports.h"
   7 #include "x86sse.h"
   8
   9 #define DISASSEM 0
  10 #define X86_TWOB 0x0f
  11
  12 #if 0
  13 static unsigned char *cptr( void (*label)() )
  14 {
  15    return (unsigned char *)(unsigned long)label;
  16 }
  17 #endif
  18
  19
  20 static void do_realloc( struct x86_function *p )
  21 {
  22    if (p->size == 0) {
  23       p->size = 1024;
  24       p->store = _mesa_exec_malloc(p->size);
  25       p->csr = p->store;
  26    }
  27    else {
  28       unsigned used = p->csr - p->store;
  29       unsigned char *tmp = p->store;
  30       p->size *= 2;
  31       p->store = _mesa_exec_malloc(p->size);
  32       memcpy(p->store, tmp, used);
  33       p->csr = p->store + used;
  34       _mesa_exec_free(tmp);
  35    }
  36 }
  37
  38 /* Emit bytes to the instruction stream:
  39  */
  40 static unsigned char *reserve( struct x86_function *p, int bytes )
  41 {
  42    if (p->csr + bytes - p->store > p->size)
  43       do_realloc(p);
  44
  45    {
  46       unsigned char *csr = p->csr;
  47       p->csr += bytes;
  48       return csr;
  49    }
  50 }
  51
  52
  53
  54 static void emit_1b( struct x86_function *p, char b0 )
  55 {
  56    char *csr = (char *)reserve(p, 1);
  57    *csr = b0;
  58 }
  59
  60 static void emit_1i( struct x86_function *p, int i0 )
  61 {
  62    int *icsr = (int *)reserve(p, sizeof(i0));
  63    *icsr = i0;
  64 }
  65
  66 static void emit_1ub( struct x86_function *p, unsigned char b0 )
  67 {
  68    unsigned char *csr = reserve(p, 1);
  69    *csr++ = b0;
  70 }
  71
  72 static void emit_2ub( struct x86_function *p, unsigned char b0, unsigned char b1 )
  73 {
  74    unsigned char *csr = reserve(p, 2);
  75    *csr++ = b0;
  76    *csr++ = b1;
  77 }
  78
  79 static void emit_3ub( struct x86_function *p, unsigned char b0, unsigned char b1, unsigned char b2 )
  80 {
  81    unsigned char *csr = reserve(p, 3);
  82    *csr++ = b0;
  83    *csr++ = b1;
  84    *csr++ = b2;
  85 }
  86
  87
  88 /* Build a modRM byte + possible displacement.  No treatment of SIB
  89  * indexing.  BZZT - no way to encode an absolute address.
  90  */
  91 static void emit_modrm( struct x86_function *p,
  92                         struct x86_reg reg,
  93                         struct x86_reg regmem )
  94 {
  95    unsigned char val = 0;
  96
  97    assert(reg.mod == mod_REG);
  98
  99    val |= regmem.mod << 6;      /* mod field */
 100    val |= reg.idx << 3;         /* reg field */
 101    val |= regmem.idx;           /* r/m field */
 102
 103    emit_1ub(p, val);
 104
 105    /* Oh-oh we've stumbled into the SIB thing.
 106     */
 107    if (regmem.file == file_REG32 &&
 108        regmem.idx == reg_SP) {
 109       emit_1ub(p, 0x24);                /* simplistic! */
 110    }
 111
 112    switch (regmem.mod) {
 113    case mod_REG:
 114    case mod_INDIRECT:
 115       break;
 116    case mod_DISP8:
 117       emit_1b(p, regmem.disp);
 118       break;
 119    case mod_DISP32:
 120       emit_1i(p, regmem.disp);
 121       break;
 122    default:
 123       assert(0);
 124       break;
 125    }
 126 }
 127
 128
 129 static void emit_modrm_noreg( struct x86_function *p,
 130                               unsigned op,
 131                               struct x86_reg regmem )
 132 {
 133    struct x86_reg dummy = x86_make_reg(file_REG32, op);
 134    emit_modrm(p, dummy, regmem);
 135 }
 136
 137 /* Many x86 instructions have two opcodes to cope with the situations
 138  * where the destination is a register or memory reference
 139  * respectively.  This function selects the correct opcode based on
 140  * the arguments presented.
 141  */
 142 static void emit_op_modrm( struct x86_function *p,
 143                            unsigned char op_dst_is_reg,
 144                            unsigned char op_dst_is_mem,
 145                            struct x86_reg dst,
 146                            struct x86_reg src )
 147 {
 148    switch (dst.mod) {
 149    case mod_REG:
 150       emit_1ub(p, op_dst_is_reg);
 151       emit_modrm(p, dst, src);
 152       break;
 153    case mod_INDIRECT:
 154    case mod_DISP32:
 155    case mod_DISP8:
 156       assert(src.mod == mod_REG);
 157       emit_1ub(p, op_dst_is_mem);
 158       emit_modrm(p, src, dst);
 159       break;
 160    default:
 161       assert(0);
 162       break;
 163    }
 164 }
 165
 166
 167
 168
 169
 170
 171
 172 /* Create and manipulate registers and regmem values:
 173  */
 174 struct x86_reg x86_make_reg( enum x86_reg_file file,
 175                              enum x86_reg_name idx )
 176 {
 177    struct x86_reg reg;
 178
 179    reg.file = file;
 180    reg.idx = idx;
 181    reg.mod = mod_REG;
 182    reg.disp = 0;
 183
 184    return reg;
 185 }
 186
 187 struct x86_reg x86_make_disp( struct x86_reg reg,
 188                               int disp )
 189 {
 190    assert(reg.file == file_REG32);
 191
 192    if (reg.mod == mod_REG)
 193       reg.disp = disp;
 194    else
 195       reg.disp += disp;
 196
 197    if (reg.disp == 0)
 198       reg.mod = mod_INDIRECT;
 199    else if (reg.disp <= 127 && reg.disp >= -128)
 200       reg.mod = mod_DISP8;
 201    else
 202       reg.mod = mod_DISP32;
 203
 204    return reg;
 205 }
 206
 207 struct x86_reg x86_deref( struct x86_reg reg )
 208 {
 209    return x86_make_disp(reg, 0);
 210 }
 211
 212 struct x86_reg x86_get_base_reg( struct x86_reg reg )
 213 {
 214    return x86_make_reg( reg.file, reg.idx );
 215 }
 216
 217 unsigned char *x86_get_label( struct x86_function *p )
 218 {
 219    return p->csr;
 220 }
 221
 222
 223
 224 /***********************************************************************
 225  * x86 instructions
 226  */
 227
 228
 229 void x86_jcc( struct x86_function *p,
 230               enum x86_cc cc,
 231               unsigned char *label )
 232 {
 233    int offset = label - (x86_get_label(p) + 2);
 234
 235    if (offset <= 127 && offset >= -128) {
 236       emit_1ub(p, 0x70 + cc);
 237       emit_1b(p, (char) offset);
 238    }
 239    else {
 240       offset = label - (x86_get_label(p) + 6);
 241       emit_2ub(p, 0x0f, 0x80 + cc);
 242       emit_1i(p, offset);
 243    }
 244 }
 245
 246 /* Always use a 32bit offset for forward jumps:
 247  */
 248 unsigned char *x86_jcc_forward( struct x86_function *p,
 249                           enum x86_cc cc )
 250 {
 251    emit_2ub(p, 0x0f, 0x80 + cc);
 252    emit_1i(p, 0);
 253    return x86_get_label(p);
 254 }
 255
 256 unsigned char *x86_jmp_forward( struct x86_function *p)
 257 {
 258    emit_1ub(p, 0xe9);
 259    emit_1i(p, 0);
 260    return x86_get_label(p);
 261 }
 262
 263 unsigned char *x86_call_forward( struct x86_function *p)
 264 {
 265    emit_1ub(p, 0xe8);
 266    emit_1i(p, 0);
 267    return x86_get_label(p);
 268 }
 269
 270 /* Fixup offset from forward jump:
 271  */
 272 void x86_fixup_fwd_jump( struct x86_function *p,
 273                          unsigned char *fixup )
 274 {
 275    *(int *)(fixup - 4) = x86_get_label(p) - fixup;
 276 }
 277
 278 void x86_jmp( struct x86_function *p, unsigned char *label)
 279 {
 280    emit_1ub(p, 0xe9);
 281    emit_1i(p, label - x86_get_label(p) - 4);
 282 }
 283
 284 #if 0
 285 /* This doesn't work once we start reallocating & copying the
 286  * generated code on buffer fills, because the call is relative to the
 287  * current pc.
 288  */
 289 void x86_call( struct x86_function *p, void (*label)())
 290 {
 291    emit_1ub(p, 0xe8);
 292    emit_1i(p, cptr(label) - x86_get_label(p) - 4);
 293 }
 294 #else
 295 void x86_call( struct x86_function *p, struct x86_reg reg)
 296 {
 297    emit_1ub(p, 0xff);
 298    emit_modrm_noreg(p, 2, reg);
 299 }
 300 #endif
 301
 302
 303 /* michal:
 304  * Temporary. As I need immediate operands, and dont want to mess with the codegen,
 305  * I load the immediate into general purpose register and use it.
 306  */
 307 void x86_mov_reg_imm( struct x86_function *p, struct x86_reg dst, int imm )
 308 {
 309    assert(dst.mod == mod_REG);
 310    emit_1ub(p, 0xb8 + dst.idx);
 311    emit_1i(p, imm);
 312 }
 313
 314 void x86_push( struct x86_function *p,
 315                struct x86_reg reg )
 316 {
 317    assert(reg.mod == mod_REG);
 318    emit_1ub(p, 0x50 + reg.idx);
 319    p->stack_offset += 4;
 320 }
 321
 322 void x86_pop( struct x86_function *p,
 323               struct x86_reg reg )
 324 {
 325    assert(reg.mod == mod_REG);
 326    emit_1ub(p, 0x58 + reg.idx);
 327    p->stack_offset -= 4;
 328 }
 329
 330 void x86_inc( struct x86_function *p,
 331               struct x86_reg reg )
 332 {
 333    assert(reg.mod == mod_REG);
 334    emit_1ub(p, 0x40 + reg.idx);
 335 }
 336
 337 void x86_dec( struct x86_function *p,
 338               struct x86_reg reg )
 339 {
 340    assert(reg.mod == mod_REG);
 341    emit_1ub(p, 0x48 + reg.idx);
 342 }
 343
 344 void x86_ret( struct x86_function *p )
 345 {
 346    emit_1ub(p, 0xc3);
 347 }
 348
 349 void x86_sahf( struct x86_function *p )
 350 {
 351    emit_1ub(p, 0x9e);
 352 }
 353
 354 void x86_mov( struct x86_function *p,
 355               struct x86_reg dst,
 356               struct x86_reg src )
 357 {
 358    emit_op_modrm( p, 0x8b, 0x89, dst, src );
 359 }
 360
 361 void x86_xor( struct x86_function *p,
 362               struct x86_reg dst,
 363               struct x86_reg src )
 364 {
 365    emit_op_modrm( p, 0x33, 0x31, dst, src );
 366 }
 367
 368 void x86_cmp( struct x86_function *p,
 369               struct x86_reg dst,
 370               struct x86_reg src )
 371 {
 372    emit_op_modrm( p, 0x3b, 0x39, dst, src );
 373 }
 374
 375 void x86_lea( struct x86_function *p,
 376               struct x86_reg dst,
 377               struct x86_reg src )
 378 {
 379    emit_1ub(p, 0x8d);
 380    emit_modrm( p, dst, src );
 381 }
 382
 383 void x86_test( struct x86_function *p,
 384                struct x86_reg dst,
 385                struct x86_reg src )
 386 {
 387    emit_1ub(p, 0x85);
 388    emit_modrm( p, dst, src );
 389 }
 390
 391 void x86_add( struct x86_function *p,
 392                struct x86_reg dst,
 393                struct x86_reg src )
 394 {
 395    emit_op_modrm(p, 0x03, 0x01, dst, src );
 396 }
 397
 398 void x86_mul( struct x86_function *p,
 399                struct x86_reg src )
 400 {
 401    assert (src.file == file_REG32 && src.mod == mod_REG);
 402    emit_op_modrm(p, 0xf7, 0, x86_make_reg (file_REG32, reg_SP), src );
 403 }
 404
 405 void x86_sub( struct x86_function *p,
 406                struct x86_reg dst,
 407                struct x86_reg src )
 408 {
 409    emit_op_modrm(p, 0x2b, 0x29, dst, src );
 410 }
 411
 412 void x86_or( struct x86_function *p,
 413              struct x86_reg dst,
 414              struct x86_reg src )
 415 {
 416    emit_op_modrm( p, 0x0b, 0x09, dst, src );
 417 }
 418
 419 void x86_and( struct x86_function *p,
 420               struct x86_reg dst,
 421               struct x86_reg src )
 422 {
 423    emit_op_modrm( p, 0x23, 0x21, dst, src );
 424 }
 425
 426
 427
 428 /***********************************************************************
 429  * SSE instructions
 430  */
 431
 432
 433 void sse_movss( struct x86_function *p,
 434                 struct x86_reg dst,
 435                 struct x86_reg src )
 436 {
 437    emit_2ub(p, 0xF3, X86_TWOB);
 438    emit_op_modrm( p, 0x10, 0x11, dst, src );
 439 }
 440
 441 void sse_movaps( struct x86_function *p,
 442                  struct x86_reg dst,
 443                  struct x86_reg src )
 444 {
 445    emit_1ub(p, X86_TWOB);
 446    emit_op_modrm( p, 0x28, 0x29, dst, src );
 447 }
 448
 449 void sse_movups( struct x86_function *p,
 450                  struct x86_reg dst,
 451                  struct x86_reg src )
 452 {
 453    emit_1ub(p, X86_TWOB);
 454    emit_op_modrm( p, 0x10, 0x11, dst, src );
 455 }
 456
 457 void sse_movhps( struct x86_function *p,
 458                  struct x86_reg dst,
 459                  struct x86_reg src )
 460 {
 461    assert(dst.mod != mod_REG || src.mod != mod_REG);
 462    emit_1ub(p, X86_TWOB);
 463    emit_op_modrm( p, 0x16, 0x17, dst, src ); /* cf movlhps */
 464 }
 465
 466 void sse_movlps( struct x86_function *p,
 467                  struct x86_reg dst,
 468                  struct x86_reg src )
 469 {
 470    assert(dst.mod != mod_REG || src.mod != mod_REG);
 471    emit_1ub(p, X86_TWOB);
 472    emit_op_modrm( p, 0x12, 0x13, dst, src ); /* cf movhlps */
 473 }
 474
 475 void sse_maxps( struct x86_function *p,
 476                 struct x86_reg dst,
 477                 struct x86_reg src )
 478 {
 479    emit_2ub(p, X86_TWOB, 0x5F);
 480    emit_modrm( p, dst, src );
 481 }
 482
 483 void sse_maxss( struct x86_function *p,
 484                 struct x86_reg dst,
 485                 struct x86_reg src )
 486 {
 487    emit_3ub(p, 0xF3, X86_TWOB, 0x5F);
 488    emit_modrm( p, dst, src );
 489 }
 490
 491 void sse_divss( struct x86_function *p,
 492                 struct x86_reg dst,
 493                 struct x86_reg src )
 494 {
 495    emit_3ub(p, 0xF3, X86_TWOB, 0x5E);
 496    emit_modrm( p, dst, src );
 497 }
 498
 499 void sse_minps( struct x86_function *p,
 500                 struct x86_reg dst,
 501                 struct x86_reg src )
 502 {
 503    emit_2ub(p, X86_TWOB, 0x5D);
 504    emit_modrm( p, dst, src );
 505 }
 506
 507 void sse_subps( struct x86_function *p,
 508                 struct x86_reg dst,
 509                 struct x86_reg src )
 510 {
 511    emit_2ub(p, X86_TWOB, 0x5C);
 512    emit_modrm( p, dst, src );
 513 }
 514
 515 void sse_mulps( struct x86_function *p,
 516                 struct x86_reg dst,
 517                 struct x86_reg src )
 518 {
 519    emit_2ub(p, X86_TWOB, 0x59);
 520    emit_modrm( p, dst, src );
 521 }
 522
 523 void sse_mulss( struct x86_function *p,
 524                 struct x86_reg dst,
 525                 struct x86_reg src )
 526 {
 527    emit_3ub(p, 0xF3, X86_TWOB, 0x59);
 528    emit_modrm( p, dst, src );
 529 }
 530
 531 void sse_addps( struct x86_function *p,
 532                 struct x86_reg dst,
 533                 struct x86_reg src )
 534 {
 535    emit_2ub(p, X86_TWOB, 0x58);
 536    emit_modrm( p, dst, src );
 537 }
 538
 539 void sse_addss( struct x86_function *p,
 540                 struct x86_reg dst,
 541                 struct x86_reg src )
 542 {
 543    emit_3ub(p, 0xF3, X86_TWOB, 0x58);
 544    emit_modrm( p, dst, src );
 545 }
 546
 547 void sse_andnps( struct x86_function *p,
 548                  struct x86_reg dst,
 549                  struct x86_reg src )
 550 {
 551    emit_2ub(p, X86_TWOB, 0x55);
 552    emit_modrm( p, dst, src );
 553 }
 554
 555 void sse_andps( struct x86_function *p,
 556                 struct x86_reg dst,
 557                 struct x86_reg src )
 558 {
 559    emit_2ub(p, X86_TWOB, 0x54);
 560    emit_modrm( p, dst, src );
 561 }
 562
 563 void sse_rsqrtps( struct x86_function *p,
 564                   struct x86_reg dst,
 565                   struct x86_reg src )
 566 {
 567    emit_2ub(p, X86_TWOB, 0x52);
 568    emit_modrm( p, dst, src );
 569 }
 570
 571 void sse_rsqrtss( struct x86_function *p,
 572                   struct x86_reg dst,
 573                   struct x86_reg src )
 574 {
 575    emit_3ub(p, 0xF3, X86_TWOB, 0x52);
 576    emit_modrm( p, dst, src );
 577
 578 }
 579
 580 void sse_movhlps( struct x86_function *p,
 581                   struct x86_reg dst,
 582                   struct x86_reg src )
 583 {
 584    assert(dst.mod == mod_REG && src.mod == mod_REG);
 585    emit_2ub(p, X86_TWOB, 0x12);
 586    emit_modrm( p, dst, src );
 587 }
 588
 589 void sse_movlhps( struct x86_function *p,
 590                   struct x86_reg dst,
 591                   struct x86_reg src )
 592 {
 593    assert(dst.mod == mod_REG && src.mod == mod_REG);
 594    emit_2ub(p, X86_TWOB, 0x16);
 595    emit_modrm( p, dst, src );
 596 }
 597
 598 void sse_orps( struct x86_function *p,
 599                struct x86_reg dst,
 600                struct x86_reg src )
 601 {
 602    emit_2ub(p, X86_TWOB, 0x56);
 603    emit_modrm( p, dst, src );
 604 }
 605
 606 void sse_xorps( struct x86_function *p,
 607                 struct x86_reg dst,
 608                 struct x86_reg src )
 609 {
 610    emit_2ub(p, X86_TWOB, 0x57);
 611    emit_modrm( p, dst, src );
 612 }
 613
 614 void sse_cvtps2pi( struct x86_function *p,
 615                    struct x86_reg dst,
 616                    struct x86_reg src )
 617 {
 618    assert(dst.file == file_MMX &&
 619           (src.file == file_XMM || src.mod != mod_REG));
 620
 621    p->need_emms = 1;
 622
 623    emit_2ub(p, X86_TWOB, 0x2d);
 624    emit_modrm( p, dst, src );
 625 }
 626
 627
 628 /* Shufps can also be used to implement a reduced swizzle when dest ==
 629  * arg0.
 630  */
 631 void sse_shufps( struct x86_function *p,
 632                  struct x86_reg dest,
 633                  struct x86_reg arg0,
 634                  unsigned char shuf)
 635 {
 636    emit_2ub(p, X86_TWOB, 0xC6);
 637    emit_modrm(p, dest, arg0);
 638    emit_1ub(p, shuf);
 639 }
 640
 641 void sse_cmpps( struct x86_function *p,
 642                 struct x86_reg dest,
 643                 struct x86_reg arg0,
 644                 unsigned char cc)
 645 {
 646    emit_2ub(p, X86_TWOB, 0xC2);
 647    emit_modrm(p, dest, arg0);
 648    emit_1ub(p, cc);
 649 }
 650
 651 void sse_pmovmskb( struct x86_function *p,
 652                    struct x86_reg dest,
 653                    struct x86_reg src)
 654 {
 655     emit_3ub(p, 0x66, X86_TWOB, 0xD7);
 656     emit_modrm(p, dest, src);
 657 }
 658
 659 /***********************************************************************
 660  * SSE2 instructions
 661  */
 662
 663 /**
 664  * Perform a reduced swizzle:
 665  */
 666 void sse2_pshufd( struct x86_function *p,
 667                   struct x86_reg dest,
 668                   struct x86_reg arg0,
 669                   unsigned char shuf)
 670 {
 671    emit_3ub(p, 0x66, X86_TWOB, 0x70);
 672    emit_modrm(p, dest, arg0);
 673    emit_1ub(p, shuf);
 674 }
 675
 676 void sse2_cvttps2dq( struct x86_function *p,
 677                      struct x86_reg dst,
 678                      struct x86_reg src )
 679 {
 680    emit_3ub( p, 0xF3, X86_TWOB, 0x5B );
 681    emit_modrm( p, dst, src );
 682 }
 683
 684 void sse2_cvtps2dq( struct x86_function *p,
 685                     struct x86_reg dst,
 686                     struct x86_reg src )
 687 {
 688    emit_3ub(p, 0x66, X86_TWOB, 0x5B);
 689    emit_modrm( p, dst, src );
 690 }
 691
 692 void sse2_packssdw( struct x86_function *p,
 693                     struct x86_reg dst,
 694                     struct x86_reg src )
 695 {
 696    emit_3ub(p, 0x66, X86_TWOB, 0x6B);
 697    emit_modrm( p, dst, src );
 698 }
 699
 700 void sse2_packsswb( struct x86_function *p,
 701                     struct x86_reg dst,
 702                     struct x86_reg src )
 703 {
 704    emit_3ub(p, 0x66, X86_TWOB, 0x63);
 705    emit_modrm( p, dst, src );
 706 }
 707
 708 void sse2_packuswb( struct x86_function *p,
 709                     struct x86_reg dst,
 710                     struct x86_reg src )
 711 {
 712    emit_3ub(p, 0x66, X86_TWOB, 0x67);
 713    emit_modrm( p, dst, src );
 714 }
 715
 716 void sse2_rcpps( struct x86_function *p,
 717                  struct x86_reg dst,
 718                  struct x86_reg src )
 719 {
 720    emit_2ub(p, X86_TWOB, 0x53);
 721    emit_modrm( p, dst, src );
 722 }
 723
 724 void sse2_rcpss( struct x86_function *p,
 725                 struct x86_reg dst,
 726                 struct x86_reg src )
 727 {
 728    emit_3ub(p, 0xF3, X86_TWOB, 0x53);
 729    emit_modrm( p, dst, src );
 730 }
 731
 732 void sse2_movd( struct x86_function *p,
 733                 struct x86_reg dst,
 734                 struct x86_reg src )
 735 {
 736    emit_2ub(p, 0x66, X86_TWOB);
 737    emit_op_modrm( p, 0x6e, 0x7e, dst, src );
 738 }
 739
 740
 741
 742
 743 /***********************************************************************
 744  * x87 instructions
 745  */
 746 void x87_fist( struct x86_function *p, struct x86_reg dst )
 747 {
 748    emit_1ub(p, 0xdb);
 749    emit_modrm_noreg(p, 2, dst);
 750 }
 751
 752 void x87_fistp( struct x86_function *p, struct x86_reg dst )
 753 {
 754    emit_1ub(p, 0xdb);
 755    emit_modrm_noreg(p, 3, dst);
 756 }
 757
 758 void x87_fild( struct x86_function *p, struct x86_reg arg )
 759 {
 760    emit_1ub(p, 0xdf);
 761    emit_modrm_noreg(p, 0, arg);
 762 }
 763
 764 void x87_fldz( struct x86_function *p )
 765 {
 766    emit_2ub(p, 0xd9, 0xee);
 767 }
 768
 769
 770 void x87_fldcw( struct x86_function *p, struct x86_reg arg )
 771 {
 772    assert(arg.file == file_REG32);
 773    assert(arg.mod != mod_REG);
 774    emit_1ub(p, 0xd9);
 775    emit_modrm_noreg(p, 5, arg);
 776 }
 777
 778 void x87_fld1( struct x86_function *p )
 779 {
 780    emit_2ub(p, 0xd9, 0xe8);
 781 }
 782
 783 void x87_fldl2e( struct x86_function *p )
 784 {
 785    emit_2ub(p, 0xd9, 0xea);
 786 }
 787
 788 void x87_fldln2( struct x86_function *p )
 789 {
 790    emit_2ub(p, 0xd9, 0xed);
 791 }
 792
 793 void x87_fwait( struct x86_function *p )
 794 {
 795    emit_1ub(p, 0x9b);
 796 }
 797
 798 void x87_fnclex( struct x86_function *p )
 799 {
 800    emit_2ub(p, 0xdb, 0xe2);
 801 }
 802
 803 void x87_fclex( struct x86_function *p )
 804 {
 805    x87_fwait(p);
 806    x87_fnclex(p);
 807 }
 808
 809
 810 static void x87_arith_op( struct x86_function *p, struct x86_reg dst, struct x86_reg arg,
 811                           unsigned char dst0ub0,
 812                           unsigned char dst0ub1,
 813                           unsigned char arg0ub0,
 814                           unsigned char arg0ub1,
 815                           unsigned char argmem_noreg)
 816 {
 817    assert(dst.file == file_x87);
 818
 819    if (arg.file == file_x87) {
 820       if (dst.idx == 0)
 821          emit_2ub(p, dst0ub0, dst0ub1+arg.idx);
 822       else if (arg.idx == 0)
 823          emit_2ub(p, arg0ub0, arg0ub1+arg.idx);
 824       else
 825          assert(0);
 826    }
 827    else if (dst.idx == 0) {
 828       assert(arg.file == file_REG32);
 829       emit_1ub(p, 0xd8);
 830       emit_modrm_noreg(p, argmem_noreg, arg);
 831    }
 832    else
 833       assert(0);
 834 }
 835
 836 void x87_fmul( struct x86_function *p, struct x86_reg dst, struct x86_reg arg )
 837 {
 838    x87_arith_op(p, dst, arg,
 839                 0xd8, 0xc8,
 840                 0xdc, 0xc8,
 841                 4);
 842 }
 843
 844 void x87_fsub( struct x86_function *p, struct x86_reg dst, struct x86_reg arg )
 845 {
 846    x87_arith_op(p, dst, arg,
 847                 0xd8, 0xe0,
 848                 0xdc, 0xe8,
 849                 4);
 850 }
 851
 852 void x87_fsubr( struct x86_function *p, struct x86_reg dst, struct x86_reg arg )
 853 {
 854    x87_arith_op(p, dst, arg,
 855                 0xd8, 0xe8,
 856                 0xdc, 0xe0,
 857                 5);
 858 }
 859
 860 void x87_fadd( struct x86_function *p, struct x86_reg dst, struct x86_reg arg )
 861 {
 862    x87_arith_op(p, dst, arg,
 863                 0xd8, 0xc0,
 864                 0xdc, 0xc0,
 865                 0);
 866 }
 867
 868 void x87_fdiv( struct x86_function *p, struct x86_reg dst, struct x86_reg arg )
 869 {
 870    x87_arith_op(p, dst, arg,
 871                 0xd8, 0xf0,
 872                 0xdc, 0xf8,
 873                 6);
 874 }
 875
 876 void x87_fdivr( struct x86_function *p, struct x86_reg dst, struct x86_reg arg )
 877 {
 878    x87_arith_op(p, dst, arg,
 879                 0xd8, 0xf8,
 880                 0xdc, 0xf0,
 881                 7);
 882 }
 883
 884 void x87_fmulp( struct x86_function *p, struct x86_reg dst )
 885 {
 886    assert(dst.file == file_x87);
 887    assert(dst.idx >= 1);
 888    emit_2ub(p, 0xde, 0xc8+dst.idx);
 889 }
 890
 891 void x87_fsubp( struct x86_function *p, struct x86_reg dst )
 892 {
 893    assert(dst.file == file_x87);
 894    assert(dst.idx >= 1);
 895    emit_2ub(p, 0xde, 0xe8+dst.idx);
 896 }
 897
 898 void x87_fsubrp( struct x86_function *p, struct x86_reg dst )
 899 {
 900    assert(dst.file == file_x87);
 901    assert(dst.idx >= 1);
 902    emit_2ub(p, 0xde, 0xe0+dst.idx);
 903 }
 904
 905 void x87_faddp( struct x86_function *p, struct x86_reg dst )
 906 {
 907    assert(dst.file == file_x87);
 908    assert(dst.idx >= 1);
 909    emit_2ub(p, 0xde, 0xc0+dst.idx);
 910 }
 911
 912 void x87_fdivp( struct x86_function *p, struct x86_reg dst )
 913 {
 914    assert(dst.file == file_x87);
 915    assert(dst.idx >= 1);
 916    emit_2ub(p, 0xde, 0xf8+dst.idx);
 917 }
 918
 919 void x87_fdivrp( struct x86_function *p, struct x86_reg dst )
 920 {
 921    assert(dst.file == file_x87);
 922    assert(dst.idx >= 1);
 923    emit_2ub(p, 0xde, 0xf0+dst.idx);
 924 }
 925
 926 void x87_fucom( struct x86_function *p, struct x86_reg arg )
 927 {
 928    assert(arg.file == file_x87);
 929    emit_2ub(p, 0xdd, 0xe0+arg.idx);
 930 }
 931
 932 void x87_fucomp( struct x86_function *p, struct x86_reg arg )
 933 {
 934    assert(arg.file == file_x87);
 935    emit_2ub(p, 0xdd, 0xe8+arg.idx);
 936 }
 937
 938 void x87_fucompp( struct x86_function *p )
 939 {
 940    emit_2ub(p, 0xda, 0xe9);
 941 }
 942
 943 void x87_fxch( struct x86_function *p, struct x86_reg arg )
 944 {
 945    assert(arg.file == file_x87);
 946    emit_2ub(p, 0xd9, 0xc8+arg.idx);
 947 }
 948
 949 void x87_fabs( struct x86_function *p )
 950 {
 951    emit_2ub(p, 0xd9, 0xe1);
 952 }
 953
 954 void x87_fchs( struct x86_function *p )
 955 {
 956    emit_2ub(p, 0xd9, 0xe0);
 957 }
 958
 959 void x87_fcos( struct x86_function *p )
 960 {
 961    emit_2ub(p, 0xd9, 0xff);
 962 }
 963
 964
 965 void x87_fprndint( struct x86_function *p )
 966 {
 967    emit_2ub(p, 0xd9, 0xfc);
 968 }
 969
 970 void x87_fscale( struct x86_function *p )
 971 {
 972    emit_2ub(p, 0xd9, 0xfd);
 973 }
 974
 975 void x87_fsin( struct x86_function *p )
 976 {
 977    emit_2ub(p, 0xd9, 0xfe);
 978 }
 979
 980 void x87_fsincos( struct x86_function *p )
 981 {
 982    emit_2ub(p, 0xd9, 0xfb);
 983 }
 984
 985 void x87_fsqrt( struct x86_function *p )
 986 {
 987    emit_2ub(p, 0xd9, 0xfa);
 988 }
 989
 990 void x87_fxtract( struct x86_function *p )
 991 {
 992    emit_2ub(p, 0xd9, 0xf4);
 993 }
 994
 995 /* st0 = (2^st0)-1
 996  *
 997  * Restrictions: -1.0 <= st0 <= 1.0
 998  */
 999 void x87_f2xm1( struct x86_function *p )
1000 {
1001    emit_2ub(p, 0xd9, 0xf0);
1002 }
1003
1004 /* st1 = st1 * log2(st0);
1005  * pop_stack;
1006  */
1007 void x87_fyl2x( struct x86_function *p )
1008 {
1009    emit_2ub(p, 0xd9, 0xf1);
1010 }
1011
1012 /* st1 = st1 * log2(st0 + 1.0);
1013  * pop_stack;
1014  *
1015  * A fast operation, with restrictions: -.29 < st0 < .29
1016  */
1017 void x87_fyl2xp1( struct x86_function *p )
1018 {
1019    emit_2ub(p, 0xd9, 0xf9);
1020 }
1021
1022
1023 void x87_fld( struct x86_function *p, struct x86_reg arg )
1024 {
1025    if (arg.file == file_x87)
1026       emit_2ub(p, 0xd9, 0xc0 + arg.idx);
1027    else {
1028       emit_1ub(p, 0xd9);
1029       emit_modrm_noreg(p, 0, arg);
1030    }
1031 }
1032
1033 void x87_fst( struct x86_function *p, struct x86_reg dst )
1034 {
1035    if (dst.file == file_x87)
1036       emit_2ub(p, 0xdd, 0xd0 + dst.idx);
1037    else {
1038       emit_1ub(p, 0xd9);
1039       emit_modrm_noreg(p, 2, dst);
1040    }
1041 }
1042
1043 void x87_fstp( struct x86_function *p, struct x86_reg dst )
1044 {
1045    if (dst.file == file_x87)
1046       emit_2ub(p, 0xdd, 0xd8 + dst.idx);
1047    else {
1048       emit_1ub(p, 0xd9);
1049       emit_modrm_noreg(p, 3, dst);
1050    }
1051 }
1052
1053 void x87_fcom( struct x86_function *p, struct x86_reg dst )
1054 {
1055    if (dst.file == file_x87)
1056       emit_2ub(p, 0xd8, 0xd0 + dst.idx);
1057    else {
1058       emit_1ub(p, 0xd8);
1059       emit_modrm_noreg(p, 2, dst);
1060    }
1061 }
1062
1063 void x87_fcomp( struct x86_function *p, struct x86_reg dst )
1064 {
1065    if (dst.file == file_x87)
1066       emit_2ub(p, 0xd8, 0xd8 + dst.idx);
1067    else {
1068       emit_1ub(p, 0xd8);
1069       emit_modrm_noreg(p, 3, dst);
1070    }
1071 }
1072
1073
1074 void x87_fnstsw( struct x86_function *p, struct x86_reg dst )
1075 {
1076    assert(dst.file == file_REG32);
1077
1078    if (dst.idx == reg_AX &&
1079        dst.mod == mod_REG)
1080       emit_2ub(p, 0xdf, 0xe0);
1081    else {
1082       emit_1ub(p, 0xdd);
1083       emit_modrm_noreg(p, 7, dst);
1084    }
1085 }
1086
1087
1088
1089
1090 /***********************************************************************
1091  * MMX instructions
1092  */
1093
1094 void mmx_emms( struct x86_function *p )
1095 {
1096    assert(p->need_emms);
1097    emit_2ub(p, 0x0f, 0x77);
1098    p->need_emms = 0;
1099 }
1100
1101 void mmx_packssdw( struct x86_function *p,
1102                    struct x86_reg dst,
1103                    struct x86_reg src )
1104 {
1105    assert(dst.file == file_MMX &&
1106           (src.file == file_MMX || src.mod != mod_REG));
1107
1108    p->need_emms = 1;
1109
1110    emit_2ub(p, X86_TWOB, 0x6b);
1111    emit_modrm( p, dst, src );
1112 }
1113
1114 void mmx_packuswb( struct x86_function *p,
1115                    struct x86_reg dst,
1116                    struct x86_reg src )
1117 {
1118    assert(dst.file == file_MMX &&
1119           (src.file == file_MMX || src.mod != mod_REG));
1120
1121    p->need_emms = 1;
1122
1123    emit_2ub(p, X86_TWOB, 0x67);
1124    emit_modrm( p, dst, src );
1125 }
1126
1127 void mmx_movd( struct x86_function *p,
1128                struct x86_reg dst,
1129                struct x86_reg src )
1130 {
1131    p->need_emms = 1;
1132    emit_1ub(p, X86_TWOB);
1133    emit_op_modrm( p, 0x6e, 0x7e, dst, src );
1134 }
1135
1136 void mmx_movq( struct x86_function *p,
1137                struct x86_reg dst,
1138                struct x86_reg src )
1139 {
1140    p->need_emms = 1;
1141    emit_1ub(p, X86_TWOB);
1142    emit_op_modrm( p, 0x6f, 0x7f, dst, src );
1143 }
1144
1145
1146 /***********************************************************************
1147  * Helper functions
1148  */
1149
1150
1151 /* Retreive a reference to one of the function arguments, taking into
1152  * account any push/pop activity:
1153  */
1154 struct x86_reg x86_fn_arg( struct x86_function *p,
1155                            unsigned arg )
1156 {
1157    return x86_make_disp(x86_make_reg(file_REG32, reg_SP),
1158                         p->stack_offset + arg * 4);     /* ??? */
1159 }
1160
1161
1162 void x86_init_func( struct x86_function *p )
1163 {
1164    p->size = 0;
1165    p->store = NULL;
1166    p->csr = p->store;
1167 }
1168
1169 int x86_init_func_size( struct x86_function *p, unsigned code_size )
1170 {
1171    p->size = code_size;
1172    p->store = _mesa_exec_malloc(code_size);
1173    p->csr = p->store;
1174    return p->store != NULL;
1175 }
1176
1177 void x86_release_func( struct x86_function *p )
1178 {
1179    _mesa_exec_free(p->store);
1180    p->store = NULL;
1181    p->csr = NULL;
1182    p->size = 0;
1183 }
1184
1185
1186 void (*x86_get_func( struct x86_function *p ))(void)
1187 {
1188    if (DISASSEM && p->store)
1189       printf("disassemble %p %p\n", p->store, p->csr);
1190    return (void (*)(void)) (unsigned long) p->store;
1191 }
1192
1193 #else
1194
1195 void x86sse_dummy( void )
1196 {
1197 }
1198
1199 #endif
1200
1201 #else  /* USE_X86_ASM */
1202
1203 int x86sse_c_dummy_var; /* silence warning */
1204
1205 #endif /* USE_X86_ASM */