src/gallium/auxiliary/rtasm/rtasm_x86sse.c

   1 /**************************************************************************
   2  *
   3  * Copyright (C) 1999-2005  Brian Paul   All Rights Reserved.
   4  *
   5  * Permission is hereby granted, free of charge, to any person obtaining a
   6  * copy of this software and associated documentation files (the "Software"),
   7  * to deal in the Software without restriction, including without limitation
   8  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
   9  * and/or sell copies of the Software, and to permit persons to whom the
  10  * Software is furnished to do so, subject to the following conditions:
  11  *
  12  * The above copyright notice and this permission notice shall be included
  13  * in all copies or substantial portions of the Software.
  14  *
  15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  16  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  17  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  18  * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
  19  * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  20  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  21  *
  22  **************************************************************************/
  23
  24 #include "pipe/p_config.h"
  25
  26 #if defined(PIPE_ARCH_X86)
  27
  28 #include "pipe/p_compiler.h"
  29 #include "pipe/p_debug.h"
  30 #include "util/u_pointer.h"
  31
  32 #include "rtasm_execmem.h"
  33 #include "rtasm_x86sse.h"
  34
  35 #define DISASSEM 0
  36 #define X86_TWOB 0x0f
  37
  38
  39 #define DUMP_SSE  0
  40
  41
  42 void x86_print_reg( struct x86_reg reg )
  43 {
  44    if (reg.mod != mod_REG)
  45       debug_printf( "[" );
  46
  47    switch( reg.file ) {
  48    case file_REG32:
  49       switch( reg.idx ) {
  50       case reg_AX: debug_printf( "EAX" ); break;
  51       case reg_CX: debug_printf( "ECX" ); break;
  52       case reg_DX: debug_printf( "EDX" ); break;
  53       case reg_BX: debug_printf( "EBX" ); break;
  54       case reg_SP: debug_printf( "ESP" ); break;
  55       case reg_BP: debug_printf( "EBP" ); break;
  56       case reg_SI: debug_printf( "ESI" ); break;
  57       case reg_DI: debug_printf( "EDI" ); break;
  58       }
  59       break;
  60    case file_MMX:
  61       debug_printf( "MMX%u", reg.idx );
  62       break;
  63    case file_XMM:
  64       debug_printf( "XMM%u", reg.idx );
  65       break;
  66    case file_x87:
  67       debug_printf( "fp%u", reg.idx );
  68       break;
  69    }
  70
  71    if (reg.mod == mod_DISP8 ||
  72        reg.mod == mod_DISP32)
  73       debug_printf("+%d", reg.disp);
  74
  75    if (reg.mod != mod_REG)
  76       debug_printf( "]" );
  77 }
  78
  79 #if DUMP_SSE
  80
  81 #define DUMP_START() debug_printf( "\n" )
  82 #define DUMP_END() debug_printf( "\n" )
  83
  84 #define DUMP() do {                             \
  85    const char *foo = __FUNCTION__;              \
  86    while (*foo && *foo != '_')                  \
  87       foo++;                                    \
  88    if  (*foo)                                   \
  89       foo++;                                    \
  90    debug_printf( "\n% 4x% 15s ", p->csr - p->store, foo );             \
  91 } while (0)
  92
  93 #define DUMP_I( I ) do {                        \
  94    DUMP();                                      \
  95    debug_printf( "%u", I );                     \
  96 } while( 0 )
  97
  98 #define DUMP_R( R0 ) do {                       \
  99    DUMP();                                      \
 100    x86_print_reg( R0 );                            \
 101 } while( 0 )
 102
 103 #define DUMP_RR( R0, R1 ) do {                  \
 104    DUMP();                                      \
 105    x86_print_reg( R0 );                            \
 106    debug_printf( ", " );                        \
 107    x86_print_reg( R1 );                            \
 108 } while( 0 )
 109
 110 #define DUMP_RI( R0, I ) do {                   \
 111    DUMP();                                      \
 112    x86_print_reg( R0 );                            \
 113    debug_printf( ", %u", I );                   \
 114 } while( 0 )
 115
 116 #define DUMP_RRI( R0, R1, I ) do {              \
 117    DUMP();                                      \
 118    x86_print_reg( R0 );                            \
 119    debug_printf( ", " );                        \
 120    x86_print_reg( R1 );                            \
 121    debug_printf( ", %u", I );                   \
 122 } while( 0 )
 123
 124 #else
 125
 126 #define DUMP_START()
 127 #define DUMP_END()
 128 #define DUMP( )
 129 #define DUMP_I( I )
 130 #define DUMP_R( R0 )
 131 #define DUMP_RR( R0, R1 )
 132 #define DUMP_RI( R0, I )
 133 #define DUMP_RRI( R0, R1, I )
 134
 135 #endif
 136
 137
 138 static void do_realloc( struct x86_function *p )
 139 {
 140    if (p->store == p->error_overflow) {
 141       p->csr = p->store;
 142    }
 143    else if (p->size == 0) {
 144       p->size = 1024;
 145       p->store = rtasm_exec_malloc(p->size);
 146       p->csr = p->store;
 147    }
 148    else {
 149       uintptr_t used = pointer_to_uintptr( p->csr ) - pointer_to_uintptr( p->store );
 150       unsigned char *tmp = p->store;
 151       p->size *= 2;
 152       p->store = rtasm_exec_malloc(p->size);
 153
 154       if (p->store) {
 155          memcpy(p->store, tmp, used);
 156          p->csr = p->store + used;
 157       }
 158       else {
 159          p->csr = p->store;
 160       }
 161
 162       rtasm_exec_free(tmp);
 163    }
 164
 165    if (p->store == NULL) {
 166       p->store = p->csr = p->error_overflow;
 167       p->size = sizeof(p->error_overflow);
 168    }
 169 }
 170
 171 /* Emit bytes to the instruction stream:
 172  */
 173 static unsigned char *reserve( struct x86_function *p, int bytes )
 174 {
 175    if (p->csr + bytes - p->store > (int) p->size)
 176       do_realloc(p);
 177
 178    {
 179       unsigned char *csr = p->csr;
 180       p->csr += bytes;
 181       return csr;
 182    }
 183 }
 184
 185
 186
 187 static void emit_1b( struct x86_function *p, char b0 )
 188 {
 189    char *csr = (char *)reserve(p, 1);
 190    *csr = b0;
 191 }
 192
 193 static void emit_1i( struct x86_function *p, int i0 )
 194 {
 195    int *icsr = (int *)reserve(p, sizeof(i0));
 196    *icsr = i0;
 197 }
 198
 199 static void emit_1ub( struct x86_function *p, unsigned char b0 )
 200 {
 201    unsigned char *csr = reserve(p, 1);
 202    *csr++ = b0;
 203 }
 204
 205 static void emit_2ub( struct x86_function *p, unsigned char b0, unsigned char b1 )
 206 {
 207    unsigned char *csr = reserve(p, 2);
 208    *csr++ = b0;
 209    *csr++ = b1;
 210 }
 211
 212 static void emit_3ub( struct x86_function *p, unsigned char b0, unsigned char b1, unsigned char b2 )
 213 {
 214    unsigned char *csr = reserve(p, 3);
 215    *csr++ = b0;
 216    *csr++ = b1;
 217    *csr++ = b2;
 218 }
 219
 220
 221 /* Build a modRM byte + possible displacement.  No treatment of SIB
 222  * indexing.  BZZT - no way to encode an absolute address.
 223  *
 224  * This is the "/r" field in the x86 manuals...
 225  */
 226 static void emit_modrm( struct x86_function *p,
 227                         struct x86_reg reg,
 228                         struct x86_reg regmem )
 229 {
 230    unsigned char val = 0;
 231
 232    assert(reg.mod == mod_REG);
 233
 234    val |= regmem.mod << 6;      /* mod field */
 235    val |= reg.idx << 3;         /* reg field */
 236    val |= regmem.idx;           /* r/m field */
 237
 238    emit_1ub(p, val);
 239
 240    /* Oh-oh we've stumbled into the SIB thing.
 241     */
 242    if (regmem.file == file_REG32 &&
 243        regmem.idx == reg_SP) {
 244       emit_1ub(p, 0x24);                /* simplistic! */
 245    }
 246
 247    switch (regmem.mod) {
 248    case mod_REG:
 249    case mod_INDIRECT:
 250       break;
 251    case mod_DISP8:
 252       emit_1b(p, (char) regmem.disp);
 253       break;
 254    case mod_DISP32:
 255       emit_1i(p, regmem.disp);
 256       break;
 257    default:
 258       assert(0);
 259       break;
 260    }
 261 }
 262
 263 /* Emits the "/0".."/7" specialized versions of the modrm ("/r") bytes.
 264  */
 265 static void emit_modrm_noreg( struct x86_function *p,
 266                               unsigned op,
 267                               struct x86_reg regmem )
 268 {
 269    struct x86_reg dummy = x86_make_reg(file_REG32, op);
 270    emit_modrm(p, dummy, regmem);
 271 }
 272
 273 /* Many x86 instructions have two opcodes to cope with the situations
 274  * where the destination is a register or memory reference
 275  * respectively.  This function selects the correct opcode based on
 276  * the arguments presented.
 277  */
 278 static void emit_op_modrm( struct x86_function *p,
 279                            unsigned char op_dst_is_reg,
 280                            unsigned char op_dst_is_mem,
 281                            struct x86_reg dst,
 282                            struct x86_reg src )
 283 {
 284    switch (dst.mod) {
 285    case mod_REG:
 286       emit_1ub(p, op_dst_is_reg);
 287       emit_modrm(p, dst, src);
 288       break;
 289    case mod_INDIRECT:
 290    case mod_DISP32:
 291    case mod_DISP8:
 292       assert(src.mod == mod_REG);
 293       emit_1ub(p, op_dst_is_mem);
 294       emit_modrm(p, src, dst);
 295       break;
 296    default:
 297       assert(0);
 298       break;
 299    }
 300 }
 301
 302
 303
 304
 305
 306
 307
 308 /* Create and manipulate registers and regmem values:
 309  */
 310 struct x86_reg x86_make_reg( enum x86_reg_file file,
 311                              enum x86_reg_name idx )
 312 {
 313    struct x86_reg reg;
 314
 315    reg.file = file;
 316    reg.idx = idx;
 317    reg.mod = mod_REG;
 318    reg.disp = 0;
 319
 320    return reg;
 321 }
 322
 323 struct x86_reg x86_make_disp( struct x86_reg reg,
 324                               int disp )
 325 {
 326    assert(reg.file == file_REG32);
 327
 328    if (reg.mod == mod_REG)
 329       reg.disp = disp;
 330    else
 331       reg.disp += disp;
 332
 333    if (reg.disp == 0 && reg.idx != reg_BP)
 334       reg.mod = mod_INDIRECT;
 335    else if (reg.disp <= 127 && reg.disp >= -128)
 336       reg.mod = mod_DISP8;
 337    else
 338       reg.mod = mod_DISP32;
 339
 340    return reg;
 341 }
 342
 343 struct x86_reg x86_deref( struct x86_reg reg )
 344 {
 345    return x86_make_disp(reg, 0);
 346 }
 347
 348 struct x86_reg x86_get_base_reg( struct x86_reg reg )
 349 {
 350    return x86_make_reg( reg.file, reg.idx );
 351 }
 352
 353 int x86_get_label( struct x86_function *p )
 354 {
 355    return p->csr - p->store;
 356 }
 357
 358
 359
 360 /***********************************************************************
 361  * x86 instructions
 362  */
 363
 364
 365 void x86_jcc( struct x86_function *p,
 366               enum x86_cc cc,
 367               int label )
 368 {
 369    int offset = label - (x86_get_label(p) + 2);
 370    DUMP_I(cc);
 371
 372    if (offset < 0) {
 373       assert(p->csr - p->store > -offset);
 374    }
 375
 376    if (offset <= 127 && offset >= -128) {
 377       emit_1ub(p, 0x70 + cc);
 378       emit_1b(p, (char) offset);
 379    }
 380    else {
 381       offset = label - (x86_get_label(p) + 6);
 382       emit_2ub(p, 0x0f, 0x80 + cc);
 383       emit_1i(p, offset);
 384    }
 385 }
 386
 387 /* Always use a 32bit offset for forward jumps:
 388  */
 389 int x86_jcc_forward( struct x86_function *p,
 390                      enum x86_cc cc )
 391 {
 392    DUMP_I(cc);
 393    emit_2ub(p, 0x0f, 0x80 + cc);
 394    emit_1i(p, 0);
 395    return x86_get_label(p);
 396 }
 397
 398 int x86_jmp_forward( struct x86_function *p)
 399 {
 400    DUMP();
 401    emit_1ub(p, 0xe9);
 402    emit_1i(p, 0);
 403    return x86_get_label(p);
 404 }
 405
 406 int x86_call_forward( struct x86_function *p)
 407 {
 408    DUMP();
 409
 410    emit_1ub(p, 0xe8);
 411    emit_1i(p, 0);
 412    return x86_get_label(p);
 413 }
 414
 415 /* Fixup offset from forward jump:
 416  */
 417 void x86_fixup_fwd_jump( struct x86_function *p,
 418                          int fixup )
 419 {
 420    *(int *)(p->store + fixup - 4) = x86_get_label(p) - fixup;
 421 }
 422
 423 void x86_jmp( struct x86_function *p, int label)
 424 {
 425    DUMP_I( label );
 426    emit_1ub(p, 0xe9);
 427    emit_1i(p, label - x86_get_label(p) - 4);
 428 }
 429
 430 void x86_call( struct x86_function *p, struct x86_reg reg)
 431 {
 432    DUMP_R( reg );
 433    emit_1ub(p, 0xff);
 434    emit_modrm_noreg(p, 2, reg);
 435 }
 436
 437
 438 /* michal:
 439  * Temporary. As I need immediate operands, and dont want to mess with the codegen,
 440  * I load the immediate into general purpose register and use it.
 441  */
 442 void x86_mov_reg_imm( struct x86_function *p, struct x86_reg dst, int imm )
 443 {
 444    DUMP_RI( dst, imm );
 445    assert(dst.mod == mod_REG);
 446    emit_1ub(p, 0xb8 + dst.idx);
 447    emit_1i(p, imm);
 448 }
 449
 450 void x86_add_reg_imm8( struct x86_function *p, struct x86_reg dst, ubyte imm )
 451 {
 452    DUMP_RI( dst, imm );
 453    assert(dst.mod == mod_REG);
 454    emit_1ub(p, 0x80);
 455    emit_modrm_noreg(p, 0, dst);
 456    emit_1ub(p, imm);
 457 }
 458
 459
 460 void x86_push( struct x86_function *p,
 461                struct x86_reg reg )
 462 {
 463    DUMP_R( reg );
 464    if (reg.mod == mod_REG)
 465       emit_1ub(p, 0x50 + reg.idx);
 466    else
 467    {
 468       emit_1ub(p, 0xff);
 469       emit_modrm_noreg(p, 6, reg);
 470    }
 471
 472
 473    p->stack_offset += 4;
 474 }
 475
 476 void x86_push_imm32( struct x86_function *p,
 477                      int imm32 )
 478 {
 479    DUMP_I( imm32 );
 480    emit_1ub(p, 0x68);
 481    emit_1i(p,  imm32);
 482
 483    p->stack_offset += 4;
 484 }
 485
 486
 487 void x86_pop( struct x86_function *p,
 488               struct x86_reg reg )
 489 {
 490    DUMP_R( reg );
 491    assert(reg.mod == mod_REG);
 492    emit_1ub(p, 0x58 + reg.idx);
 493    p->stack_offset -= 4;
 494 }
 495
 496 void x86_inc( struct x86_function *p,
 497               struct x86_reg reg )
 498 {
 499    DUMP_R( reg );
 500    assert(reg.mod == mod_REG);
 501    emit_1ub(p, 0x40 + reg.idx);
 502 }
 503
 504 void x86_dec( struct x86_function *p,
 505               struct x86_reg reg )
 506 {
 507    DUMP_R( reg );
 508    assert(reg.mod == mod_REG);
 509    emit_1ub(p, 0x48 + reg.idx);
 510 }
 511
 512 void x86_ret( struct x86_function *p )
 513 {
 514    DUMP();
 515    assert(p->stack_offset == 0);
 516    emit_1ub(p, 0xc3);
 517 }
 518
 519 void x86_retw( struct x86_function *p, unsigned short imm )
 520 {
 521    DUMP();
 522    emit_3ub(p, 0xc2, imm & 0xff, (imm >> 8) & 0xff);
 523 }
 524
 525 void x86_sahf( struct x86_function *p )
 526 {
 527    DUMP();
 528    emit_1ub(p, 0x9e);
 529 }
 530
 531 void x86_mov( struct x86_function *p,
 532               struct x86_reg dst,
 533               struct x86_reg src )
 534 {
 535    DUMP_RR( dst, src );
 536    emit_op_modrm( p, 0x8b, 0x89, dst, src );
 537 }
 538
 539 void x86_xor( struct x86_function *p,
 540               struct x86_reg dst,
 541               struct x86_reg src )
 542 {
 543    DUMP_RR( dst, src );
 544    emit_op_modrm( p, 0x33, 0x31, dst, src );
 545 }
 546
 547 void x86_cmp( struct x86_function *p,
 548               struct x86_reg dst,
 549               struct x86_reg src )
 550 {
 551    DUMP_RR( dst, src );
 552    emit_op_modrm( p, 0x3b, 0x39, dst, src );
 553 }
 554
 555 void x86_lea( struct x86_function *p,
 556               struct x86_reg dst,
 557               struct x86_reg src )
 558 {
 559    DUMP_RR( dst, src );
 560    emit_1ub(p, 0x8d);
 561    emit_modrm( p, dst, src );
 562 }
 563
 564 void x86_test( struct x86_function *p,
 565                struct x86_reg dst,
 566                struct x86_reg src )
 567 {
 568    DUMP_RR( dst, src );
 569    emit_1ub(p, 0x85);
 570    emit_modrm( p, dst, src );
 571 }
 572
 573 void x86_add( struct x86_function *p,
 574                struct x86_reg dst,
 575                struct x86_reg src )
 576 {
 577    DUMP_RR( dst, src );
 578    emit_op_modrm(p, 0x03, 0x01, dst, src );
 579 }
 580
 581 /* Calculate EAX * src, results in EDX:EAX.
 582  */
 583 void x86_mul( struct x86_function *p,
 584                struct x86_reg src )
 585 {
 586    DUMP_R(  src );
 587    emit_1ub(p, 0xf7);
 588    emit_modrm_noreg(p, 4, src );
 589 }
 590
 591
 592 void x86_imul( struct x86_function *p,
 593                struct x86_reg dst,
 594                struct x86_reg src )
 595 {
 596    DUMP_RR( dst, src );
 597    emit_2ub(p, X86_TWOB, 0xAF);
 598    emit_modrm(p, dst, src);
 599 }
 600
 601
 602 void x86_sub( struct x86_function *p,
 603                struct x86_reg dst,
 604                struct x86_reg src )
 605 {
 606    DUMP_RR( dst, src );
 607    emit_op_modrm(p, 0x2b, 0x29, dst, src );
 608 }
 609
 610 void x86_or( struct x86_function *p,
 611              struct x86_reg dst,
 612              struct x86_reg src )
 613 {
 614    DUMP_RR( dst, src );
 615    emit_op_modrm( p, 0x0b, 0x09, dst, src );
 616 }
 617
 618 void x86_and( struct x86_function *p,
 619               struct x86_reg dst,
 620               struct x86_reg src )
 621 {
 622    DUMP_RR( dst, src );
 623    emit_op_modrm( p, 0x23, 0x21, dst, src );
 624 }
 625
 626
 627
 628 /***********************************************************************
 629  * SSE instructions
 630  */
 631
 632
 633 void sse_movss( struct x86_function *p,
 634                 struct x86_reg dst,
 635                 struct x86_reg src )
 636 {
 637    DUMP_RR( dst, src );
 638    emit_2ub(p, 0xF3, X86_TWOB);
 639    emit_op_modrm( p, 0x10, 0x11, dst, src );
 640 }
 641
 642 void sse_movaps( struct x86_function *p,
 643                  struct x86_reg dst,
 644                  struct x86_reg src )
 645 {
 646    DUMP_RR( dst, src );
 647    emit_1ub(p, X86_TWOB);
 648    emit_op_modrm( p, 0x28, 0x29, dst, src );
 649 }
 650
 651 void sse_movups( struct x86_function *p,
 652                  struct x86_reg dst,
 653                  struct x86_reg src )
 654 {
 655    DUMP_RR( dst, src );
 656    emit_1ub(p, X86_TWOB);
 657    emit_op_modrm( p, 0x10, 0x11, dst, src );
 658 }
 659
 660 void sse_movhps( struct x86_function *p,
 661                  struct x86_reg dst,
 662                  struct x86_reg src )
 663 {
 664    DUMP_RR( dst, src );
 665    assert(dst.mod != mod_REG || src.mod != mod_REG);
 666    emit_1ub(p, X86_TWOB);
 667    emit_op_modrm( p, 0x16, 0x17, dst, src ); /* cf movlhps */
 668 }
 669
 670 void sse_movlps( struct x86_function *p,
 671                  struct x86_reg dst,
 672                  struct x86_reg src )
 673 {
 674    DUMP_RR( dst, src );
 675    assert(dst.mod != mod_REG || src.mod != mod_REG);
 676    emit_1ub(p, X86_TWOB);
 677    emit_op_modrm( p, 0x12, 0x13, dst, src ); /* cf movhlps */
 678 }
 679
 680 void sse_maxps( struct x86_function *p,
 681                 struct x86_reg dst,
 682                 struct x86_reg src )
 683 {
 684    DUMP_RR( dst, src );
 685    emit_2ub(p, X86_TWOB, 0x5F);
 686    emit_modrm( p, dst, src );
 687 }
 688
 689 void sse_maxss( struct x86_function *p,
 690                 struct x86_reg dst,
 691                 struct x86_reg src )
 692 {
 693    DUMP_RR( dst, src );
 694    emit_3ub(p, 0xF3, X86_TWOB, 0x5F);
 695    emit_modrm( p, dst, src );
 696 }
 697
 698 void sse_divss( struct x86_function *p,
 699                 struct x86_reg dst,
 700                 struct x86_reg src )
 701 {
 702    DUMP_RR( dst, src );
 703    emit_3ub(p, 0xF3, X86_TWOB, 0x5E);
 704    emit_modrm( p, dst, src );
 705 }
 706
 707 void sse_minps( struct x86_function *p,
 708                 struct x86_reg dst,
 709                 struct x86_reg src )
 710 {
 711    DUMP_RR( dst, src );
 712    emit_2ub(p, X86_TWOB, 0x5D);
 713    emit_modrm( p, dst, src );
 714 }
 715
 716 void sse_subps( struct x86_function *p,
 717                 struct x86_reg dst,
 718                 struct x86_reg src )
 719 {
 720    DUMP_RR( dst, src );
 721    emit_2ub(p, X86_TWOB, 0x5C);
 722    emit_modrm( p, dst, src );
 723 }
 724
 725 void sse_mulps( struct x86_function *p,
 726                 struct x86_reg dst,
 727                 struct x86_reg src )
 728 {
 729    DUMP_RR( dst, src );
 730    emit_2ub(p, X86_TWOB, 0x59);
 731    emit_modrm( p, dst, src );
 732 }
 733
 734 void sse_mulss( struct x86_function *p,
 735                 struct x86_reg dst,
 736                 struct x86_reg src )
 737 {
 738    DUMP_RR( dst, src );
 739    emit_3ub(p, 0xF3, X86_TWOB, 0x59);
 740    emit_modrm( p, dst, src );
 741 }
 742
 743 void sse_addps( struct x86_function *p,
 744                 struct x86_reg dst,
 745                 struct x86_reg src )
 746 {
 747    DUMP_RR( dst, src );
 748    emit_2ub(p, X86_TWOB, 0x58);
 749    emit_modrm( p, dst, src );
 750 }
 751
 752 void sse_addss( struct x86_function *p,
 753                 struct x86_reg dst,
 754                 struct x86_reg src )
 755 {
 756    DUMP_RR( dst, src );
 757    emit_3ub(p, 0xF3, X86_TWOB, 0x58);
 758    emit_modrm( p, dst, src );
 759 }
 760
 761 void sse_andnps( struct x86_function *p,
 762                  struct x86_reg dst,
 763                  struct x86_reg src )
 764 {
 765    DUMP_RR( dst, src );
 766    emit_2ub(p, X86_TWOB, 0x55);
 767    emit_modrm( p, dst, src );
 768 }
 769
 770 void sse_andps( struct x86_function *p,
 771                 struct x86_reg dst,
 772                 struct x86_reg src )
 773 {
 774    DUMP_RR( dst, src );
 775    emit_2ub(p, X86_TWOB, 0x54);
 776    emit_modrm( p, dst, src );
 777 }
 778
 779 void sse_rsqrtps( struct x86_function *p,
 780                   struct x86_reg dst,
 781                   struct x86_reg src )
 782 {
 783    DUMP_RR( dst, src );
 784    emit_2ub(p, X86_TWOB, 0x52);
 785    emit_modrm( p, dst, src );
 786 }
 787
 788 void sse_rsqrtss( struct x86_function *p,
 789                   struct x86_reg dst,
 790                   struct x86_reg src )
 791 {
 792    DUMP_RR( dst, src );
 793    emit_3ub(p, 0xF3, X86_TWOB, 0x52);
 794    emit_modrm( p, dst, src );
 795
 796 }
 797
 798 void sse_movhlps( struct x86_function *p,
 799                   struct x86_reg dst,
 800                   struct x86_reg src )
 801 {
 802    DUMP_RR( dst, src );
 803    assert(dst.mod == mod_REG && src.mod == mod_REG);
 804    emit_2ub(p, X86_TWOB, 0x12);
 805    emit_modrm( p, dst, src );
 806 }
 807
 808 void sse_movlhps( struct x86_function *p,
 809                   struct x86_reg dst,
 810                   struct x86_reg src )
 811 {
 812    DUMP_RR( dst, src );
 813    assert(dst.mod == mod_REG && src.mod == mod_REG);
 814    emit_2ub(p, X86_TWOB, 0x16);
 815    emit_modrm( p, dst, src );
 816 }
 817
 818 void sse_orps( struct x86_function *p,
 819                struct x86_reg dst,
 820                struct x86_reg src )
 821 {
 822    DUMP_RR( dst, src );
 823    emit_2ub(p, X86_TWOB, 0x56);
 824    emit_modrm( p, dst, src );
 825 }
 826
 827 void sse_xorps( struct x86_function *p,
 828                 struct x86_reg dst,
 829                 struct x86_reg src )
 830 {
 831    DUMP_RR( dst, src );
 832    emit_2ub(p, X86_TWOB, 0x57);
 833    emit_modrm( p, dst, src );
 834 }
 835
 836 void sse_cvtps2pi( struct x86_function *p,
 837                    struct x86_reg dst,
 838                    struct x86_reg src )
 839 {
 840    DUMP_RR( dst, src );
 841    assert(dst.file == file_MMX &&
 842           (src.file == file_XMM || src.mod != mod_REG));
 843
 844    p->need_emms = 1;
 845
 846    emit_2ub(p, X86_TWOB, 0x2d);
 847    emit_modrm( p, dst, src );
 848 }
 849
 850 void sse2_cvtdq2ps( struct x86_function *p,
 851                    struct x86_reg dst,
 852                    struct x86_reg src )
 853 {
 854    DUMP_RR( dst, src );
 855    emit_2ub(p, X86_TWOB, 0x5b);
 856    emit_modrm( p, dst, src );
 857 }
 858
 859
 860 /* Shufps can also be used to implement a reduced swizzle when dest ==
 861  * arg0.
 862  */
 863 void sse_shufps( struct x86_function *p,
 864                  struct x86_reg dst,
 865                  struct x86_reg src,
 866                  unsigned char shuf)
 867 {
 868    DUMP_RRI( dst, src, shuf );
 869    emit_2ub(p, X86_TWOB, 0xC6);
 870    emit_modrm(p, dst, src);
 871    emit_1ub(p, shuf);
 872 }
 873
 874 void sse_unpckhps( struct x86_function *p, struct x86_reg dst, struct x86_reg src )
 875 {
 876    DUMP_RR( dst, src );
 877    emit_2ub( p, X86_TWOB, 0x15 );
 878    emit_modrm( p, dst, src );
 879 }
 880
 881 void sse_unpcklps( struct x86_function *p, struct x86_reg dst, struct x86_reg src )
 882 {
 883    DUMP_RR( dst, src );
 884    emit_2ub( p, X86_TWOB, 0x14 );
 885    emit_modrm( p, dst, src );
 886 }
 887
 888 void sse_cmpps( struct x86_function *p,
 889                 struct x86_reg dst,
 890                 struct x86_reg src,
 891                 enum sse_cc cc)
 892 {
 893    DUMP_RRI( dst, src, cc );
 894    emit_2ub(p, X86_TWOB, 0xC2);
 895    emit_modrm(p, dst, src);
 896    emit_1ub(p, cc);
 897 }
 898
 899 void sse_pmovmskb( struct x86_function *p,
 900                    struct x86_reg dst,
 901                    struct x86_reg src)
 902 {
 903    DUMP_RR( dst, src );
 904    emit_3ub(p, 0x66, X86_TWOB, 0xD7);
 905    emit_modrm(p, dst, src);
 906 }
 907
 908 /***********************************************************************
 909  * SSE2 instructions
 910  */
 911
 912 /**
 913  * Perform a reduced swizzle:
 914  */
 915 void sse2_pshufd( struct x86_function *p,
 916                   struct x86_reg dst,
 917                   struct x86_reg src,
 918                   unsigned char shuf)
 919 {
 920    DUMP_RRI( dst, src, shuf );
 921    emit_3ub(p, 0x66, X86_TWOB, 0x70);
 922    emit_modrm(p, dst, src);
 923    emit_1ub(p, shuf);
 924 }
 925
 926 void sse2_cvttps2dq( struct x86_function *p,
 927                      struct x86_reg dst,
 928                      struct x86_reg src )
 929 {
 930    DUMP_RR( dst, src );
 931    emit_3ub( p, 0xF3, X86_TWOB, 0x5B );
 932    emit_modrm( p, dst, src );
 933 }
 934
 935 void sse2_cvtps2dq( struct x86_function *p,
 936                     struct x86_reg dst,
 937                     struct x86_reg src )
 938 {
 939    DUMP_RR( dst, src );
 940    emit_3ub(p, 0x66, X86_TWOB, 0x5B);
 941    emit_modrm( p, dst, src );
 942 }
 943
 944 void sse2_packssdw( struct x86_function *p,
 945                     struct x86_reg dst,
 946                     struct x86_reg src )
 947 {
 948    DUMP_RR( dst, src );
 949    emit_3ub(p, 0x66, X86_TWOB, 0x6B);
 950    emit_modrm( p, dst, src );
 951 }
 952
 953 void sse2_packsswb( struct x86_function *p,
 954                     struct x86_reg dst,
 955                     struct x86_reg src )
 956 {
 957    DUMP_RR( dst, src );
 958    emit_3ub(p, 0x66, X86_TWOB, 0x63);
 959    emit_modrm( p, dst, src );
 960 }
 961
 962 void sse2_packuswb( struct x86_function *p,
 963                     struct x86_reg dst,
 964                     struct x86_reg src )
 965 {
 966    DUMP_RR( dst, src );
 967    emit_3ub(p, 0x66, X86_TWOB, 0x67);
 968    emit_modrm( p, dst, src );
 969 }
 970
 971 void sse2_punpcklbw( struct x86_function *p,
 972                     struct x86_reg dst,
 973                     struct x86_reg src )
 974 {
 975    DUMP_RR( dst, src );
 976    emit_3ub(p, 0x66, X86_TWOB, 0x60);
 977    emit_modrm( p, dst, src );
 978 }
 979
 980
 981 void sse2_rcpps( struct x86_function *p,
 982                  struct x86_reg dst,
 983                  struct x86_reg src )
 984 {
 985    DUMP_RR( dst, src );
 986    emit_2ub(p, X86_TWOB, 0x53);
 987    emit_modrm( p, dst, src );
 988 }
 989
 990 void sse2_rcpss( struct x86_function *p,
 991                 struct x86_reg dst,
 992                 struct x86_reg src )
 993 {
 994    DUMP_RR( dst, src );
 995    emit_3ub(p, 0xF3, X86_TWOB, 0x53);
 996    emit_modrm( p, dst, src );
 997 }
 998
 999 void sse2_movd( struct x86_function *p,
1000                 struct x86_reg dst,
1001                 struct x86_reg src )
1002 {
1003    DUMP_RR( dst, src );
1004    emit_2ub(p, 0x66, X86_TWOB);
1005    emit_op_modrm( p, 0x6e, 0x7e, dst, src );
1006 }
1007
1008
1009
1010
1011 /***********************************************************************
1012  * x87 instructions
1013  */
1014 static void note_x87_pop( struct x86_function *p )
1015 {
1016    p->x87_stack--;
1017    assert(p->x87_stack >= 0);
1018 }
1019
1020 static void note_x87_push( struct x86_function *p )
1021 {
1022    p->x87_stack++;
1023    assert(p->x87_stack <= 7);
1024 }
1025
1026 void x87_assert_stack_empty( struct x86_function *p )
1027 {
1028    assert (p->x87_stack == 0);
1029 }
1030
1031
1032 void x87_fist( struct x86_function *p, struct x86_reg dst )
1033 {
1034    DUMP_R( dst );
1035    emit_1ub(p, 0xdb);
1036    emit_modrm_noreg(p, 2, dst);
1037 }
1038
1039 void x87_fistp( struct x86_function *p, struct x86_reg dst )
1040 {
1041    DUMP_R( dst );
1042    emit_1ub(p, 0xdb);
1043    emit_modrm_noreg(p, 3, dst);
1044    note_x87_pop(p);
1045 }
1046
1047 void x87_fild( struct x86_function *p, struct x86_reg arg )
1048 {
1049    DUMP_R( arg );
1050    emit_1ub(p, 0xdf);
1051    emit_modrm_noreg(p, 0, arg);
1052    note_x87_push(p);
1053 }
1054
1055 void x87_fldz( struct x86_function *p )
1056 {
1057    DUMP();
1058    emit_2ub(p, 0xd9, 0xee);
1059    note_x87_push(p);
1060 }
1061
1062
1063 void x87_fldcw( struct x86_function *p, struct x86_reg arg )
1064 {
1065    DUMP_R( arg );
1066    assert(arg.file == file_REG32);
1067    assert(arg.mod != mod_REG);
1068    emit_1ub(p, 0xd9);
1069    emit_modrm_noreg(p, 5, arg);
1070 }
1071
1072 void x87_fld1( struct x86_function *p )
1073 {
1074    DUMP();
1075    emit_2ub(p, 0xd9, 0xe8);
1076    note_x87_push(p);
1077 }
1078
1079 void x87_fldl2e( struct x86_function *p )
1080 {
1081    DUMP();
1082    emit_2ub(p, 0xd9, 0xea);
1083    note_x87_push(p);
1084 }
1085
1086 void x87_fldln2( struct x86_function *p )
1087 {
1088    DUMP();
1089    emit_2ub(p, 0xd9, 0xed);
1090    note_x87_push(p);
1091 }
1092
1093 void x87_fwait( struct x86_function *p )
1094 {
1095    DUMP();
1096    emit_1ub(p, 0x9b);
1097 }
1098
1099 void x87_fnclex( struct x86_function *p )
1100 {
1101    DUMP();
1102    emit_2ub(p, 0xdb, 0xe2);
1103 }
1104
1105 void x87_fclex( struct x86_function *p )
1106 {
1107    x87_fwait(p);
1108    x87_fnclex(p);
1109 }
1110
1111 void x87_fcmovb( struct x86_function *p, struct x86_reg arg )
1112 {
1113    DUMP_R( arg );
1114    assert(arg.file == file_x87);
1115    emit_2ub(p, 0xda, 0xc0+arg.idx);
1116 }
1117
1118 void x87_fcmove( struct x86_function *p, struct x86_reg arg )
1119 {
1120    DUMP_R( arg );
1121    assert(arg.file == file_x87);
1122    emit_2ub(p, 0xda, 0xc8+arg.idx);
1123 }
1124
1125 void x87_fcmovbe( struct x86_function *p, struct x86_reg arg )
1126 {
1127    DUMP_R( arg );
1128    assert(arg.file == file_x87);
1129    emit_2ub(p, 0xda, 0xd0+arg.idx);
1130 }
1131
1132 void x87_fcmovnb( struct x86_function *p, struct x86_reg arg )
1133 {
1134    DUMP_R( arg );
1135    assert(arg.file == file_x87);
1136    emit_2ub(p, 0xdb, 0xc0+arg.idx);
1137 }
1138
1139 void x87_fcmovne( struct x86_function *p, struct x86_reg arg )
1140 {
1141    DUMP_R( arg );
1142    assert(arg.file == file_x87);
1143    emit_2ub(p, 0xdb, 0xc8+arg.idx);
1144 }
1145
1146 void x87_fcmovnbe( struct x86_function *p, struct x86_reg arg )
1147 {
1148    DUMP_R( arg );
1149    assert(arg.file == file_x87);
1150    emit_2ub(p, 0xdb, 0xd0+arg.idx);
1151 }
1152
1153
1154
1155 static void x87_arith_op( struct x86_function *p, struct x86_reg dst, struct x86_reg arg,
1156                           unsigned char dst0ub0,
1157                           unsigned char dst0ub1,
1158                           unsigned char arg0ub0,
1159                           unsigned char arg0ub1,
1160                           unsigned char argmem_noreg)
1161 {
1162    assert(dst.file == file_x87);
1163
1164    if (arg.file == file_x87) {
1165       if (dst.idx == 0)
1166          emit_2ub(p, dst0ub0, dst0ub1+arg.idx);
1167       else if (arg.idx == 0)
1168          emit_2ub(p, arg0ub0, arg0ub1+arg.idx);
1169       else
1170          assert(0);
1171    }
1172    else if (dst.idx == 0) {
1173       assert(arg.file == file_REG32);
1174       emit_1ub(p, 0xd8);
1175       emit_modrm_noreg(p, argmem_noreg, arg);
1176    }
1177    else
1178       assert(0);
1179 }
1180
1181 void x87_fmul( struct x86_function *p, struct x86_reg dst, struct x86_reg src )
1182 {
1183    DUMP_RR( dst, src );
1184    x87_arith_op(p, dst, src,
1185                 0xd8, 0xc8,
1186                 0xdc, 0xc8,
1187                 4);
1188 }
1189
1190 void x87_fsub( struct x86_function *p, struct x86_reg dst, struct x86_reg src )
1191 {
1192    DUMP_RR( dst, src );
1193    x87_arith_op(p, dst, src,
1194                 0xd8, 0xe0,
1195                 0xdc, 0xe8,
1196                 4);
1197 }
1198
1199 void x87_fsubr( struct x86_function *p, struct x86_reg dst, struct x86_reg src )
1200 {
1201    DUMP_RR( dst, src );
1202    x87_arith_op(p, dst, src,
1203                 0xd8, 0xe8,
1204                 0xdc, 0xe0,
1205                 5);
1206 }
1207
1208 void x87_fadd( struct x86_function *p, struct x86_reg dst, struct x86_reg src )
1209 {
1210    DUMP_RR( dst, src );
1211    x87_arith_op(p, dst, src,
1212                 0xd8, 0xc0,
1213                 0xdc, 0xc0,
1214                 0);
1215 }
1216
1217 void x87_fdiv( struct x86_function *p, struct x86_reg dst, struct x86_reg src )
1218 {
1219    DUMP_RR( dst, src );
1220    x87_arith_op(p, dst, src,
1221                 0xd8, 0xf0,
1222                 0xdc, 0xf8,
1223                 6);
1224 }
1225
1226 void x87_fdivr( struct x86_function *p, struct x86_reg dst, struct x86_reg src )
1227 {
1228    DUMP_RR( dst, src );
1229    x87_arith_op(p, dst, src,
1230                 0xd8, 0xf8,
1231                 0xdc, 0xf0,
1232                 7);
1233 }
1234
1235 void x87_fmulp( struct x86_function *p, struct x86_reg dst )
1236 {
1237    DUMP_R( dst );
1238    assert(dst.file == file_x87);
1239    assert(dst.idx >= 1);
1240    emit_2ub(p, 0xde, 0xc8+dst.idx);
1241    note_x87_pop(p);
1242 }
1243
1244 void x87_fsubp( struct x86_function *p, struct x86_reg dst )
1245 {
1246    DUMP_R( dst );
1247    assert(dst.file == file_x87);
1248    assert(dst.idx >= 1);
1249    emit_2ub(p, 0xde, 0xe8+dst.idx);
1250    note_x87_pop(p);
1251 }
1252
1253 void x87_fsubrp( struct x86_function *p, struct x86_reg dst )
1254 {
1255    DUMP_R( dst );
1256    assert(dst.file == file_x87);
1257    assert(dst.idx >= 1);
1258    emit_2ub(p, 0xde, 0xe0+dst.idx);
1259    note_x87_pop(p);
1260 }
1261
1262 void x87_faddp( struct x86_function *p, struct x86_reg dst )
1263 {
1264    DUMP_R( dst );
1265    assert(dst.file == file_x87);
1266    assert(dst.idx >= 1);
1267    emit_2ub(p, 0xde, 0xc0+dst.idx);
1268    note_x87_pop(p);
1269 }
1270
1271 void x87_fdivp( struct x86_function *p, struct x86_reg dst )
1272 {
1273    DUMP_R( dst );
1274    assert(dst.file == file_x87);
1275    assert(dst.idx >= 1);
1276    emit_2ub(p, 0xde, 0xf8+dst.idx);
1277    note_x87_pop(p);
1278 }
1279
1280 void x87_fdivrp( struct x86_function *p, struct x86_reg dst )
1281 {
1282    DUMP_R( dst );
1283    assert(dst.file == file_x87);
1284    assert(dst.idx >= 1);
1285    emit_2ub(p, 0xde, 0xf0+dst.idx);
1286    note_x87_pop(p);
1287 }
1288
1289 void x87_ftst( struct x86_function *p )
1290 {
1291    DUMP();
1292    emit_2ub(p, 0xd9, 0xe4);
1293 }
1294
1295 void x87_fucom( struct x86_function *p, struct x86_reg arg )
1296 {
1297    DUMP_R( arg );
1298    assert(arg.file == file_x87);
1299    emit_2ub(p, 0xdd, 0xe0+arg.idx);
1300 }
1301
1302 void x87_fucomp( struct x86_function *p, struct x86_reg arg )
1303 {
1304    DUMP_R( arg );
1305    assert(arg.file == file_x87);
1306    emit_2ub(p, 0xdd, 0xe8+arg.idx);
1307    note_x87_pop(p);
1308 }
1309
1310 void x87_fucompp( struct x86_function *p )
1311 {
1312    DUMP();
1313    emit_2ub(p, 0xda, 0xe9);
1314    note_x87_pop(p);             /* pop twice */
1315    note_x87_pop(p);             /* pop twice */
1316 }
1317
1318 void x87_fxch( struct x86_function *p, struct x86_reg arg )
1319 {
1320    DUMP_R( arg );
1321    assert(arg.file == file_x87);
1322    emit_2ub(p, 0xd9, 0xc8+arg.idx);
1323 }
1324
1325 void x87_fabs( struct x86_function *p )
1326 {
1327    DUMP();
1328    emit_2ub(p, 0xd9, 0xe1);
1329 }
1330
1331 void x87_fchs( struct x86_function *p )
1332 {
1333    DUMP();
1334    emit_2ub(p, 0xd9, 0xe0);
1335 }
1336
1337 void x87_fcos( struct x86_function *p )
1338 {
1339    DUMP();
1340    emit_2ub(p, 0xd9, 0xff);
1341 }
1342
1343
1344 void x87_fprndint( struct x86_function *p )
1345 {
1346    DUMP();
1347    emit_2ub(p, 0xd9, 0xfc);
1348 }
1349
1350 void x87_fscale( struct x86_function *p )
1351 {
1352    DUMP();
1353    emit_2ub(p, 0xd9, 0xfd);
1354 }
1355
1356 void x87_fsin( struct x86_function *p )
1357 {
1358    DUMP();
1359    emit_2ub(p, 0xd9, 0xfe);
1360 }
1361
1362 void x87_fsincos( struct x86_function *p )
1363 {
1364    DUMP();
1365    emit_2ub(p, 0xd9, 0xfb);
1366 }
1367
1368 void x87_fsqrt( struct x86_function *p )
1369 {
1370    DUMP();
1371    emit_2ub(p, 0xd9, 0xfa);
1372 }
1373
1374 void x87_fxtract( struct x86_function *p )
1375 {
1376    DUMP();
1377    emit_2ub(p, 0xd9, 0xf4);
1378 }
1379
1380 /* st0 = (2^st0)-1
1381  *
1382  * Restrictions: -1.0 <= st0 <= 1.0
1383  */
1384 void x87_f2xm1( struct x86_function *p )
1385 {
1386    DUMP();
1387    emit_2ub(p, 0xd9, 0xf0);
1388 }
1389
1390 /* st1 = st1 * log2(st0);
1391  * pop_stack;
1392  */
1393 void x87_fyl2x( struct x86_function *p )
1394 {
1395    DUMP();
1396    emit_2ub(p, 0xd9, 0xf1);
1397    note_x87_pop(p);
1398 }
1399
1400 /* st1 = st1 * log2(st0 + 1.0);
1401  * pop_stack;
1402  *
1403  * A fast operation, with restrictions: -.29 < st0 < .29
1404  */
1405 void x87_fyl2xp1( struct x86_function *p )
1406 {
1407    DUMP();
1408    emit_2ub(p, 0xd9, 0xf9);
1409    note_x87_pop(p);
1410 }
1411
1412
1413 void x87_fld( struct x86_function *p, struct x86_reg arg )
1414 {
1415    DUMP_R( arg );
1416    if (arg.file == file_x87)
1417       emit_2ub(p, 0xd9, 0xc0 + arg.idx);
1418    else {
1419       emit_1ub(p, 0xd9);
1420       emit_modrm_noreg(p, 0, arg);
1421    }
1422    note_x87_push(p);
1423 }
1424
1425 void x87_fst( struct x86_function *p, struct x86_reg dst )
1426 {
1427    DUMP_R( dst );
1428    if (dst.file == file_x87)
1429       emit_2ub(p, 0xdd, 0xd0 + dst.idx);
1430    else {
1431       emit_1ub(p, 0xd9);
1432       emit_modrm_noreg(p, 2, dst);
1433    }
1434 }
1435
1436 void x87_fstp( struct x86_function *p, struct x86_reg dst )
1437 {
1438    DUMP_R( dst );
1439    if (dst.file == file_x87)
1440       emit_2ub(p, 0xdd, 0xd8 + dst.idx);
1441    else {
1442       emit_1ub(p, 0xd9);
1443       emit_modrm_noreg(p, 3, dst);
1444    }
1445    note_x87_pop(p);
1446 }
1447
1448 void x87_fpop( struct x86_function *p )
1449 {
1450    x87_fstp( p, x86_make_reg( file_x87, 0 ));
1451 }
1452
1453
1454 void x87_fcom( struct x86_function *p, struct x86_reg dst )
1455 {
1456    DUMP_R( dst );
1457    if (dst.file == file_x87)
1458       emit_2ub(p, 0xd8, 0xd0 + dst.idx);
1459    else {
1460       emit_1ub(p, 0xd8);
1461       emit_modrm_noreg(p, 2, dst);
1462    }
1463 }
1464
1465
1466 void x87_fcomp( struct x86_function *p, struct x86_reg dst )
1467 {
1468    DUMP_R( dst );
1469    if (dst.file == file_x87)
1470       emit_2ub(p, 0xd8, 0xd8 + dst.idx);
1471    else {
1472       emit_1ub(p, 0xd8);
1473       emit_modrm_noreg(p, 3, dst);
1474    }
1475    note_x87_pop(p);
1476 }
1477
1478 void x87_fcomi( struct x86_function *p, struct x86_reg arg )
1479 {
1480    DUMP_R( arg );
1481    emit_2ub(p, 0xdb, 0xf0+arg.idx);
1482 }
1483
1484 void x87_fcomip( struct x86_function *p, struct x86_reg arg )
1485 {
1486    DUMP_R( arg );
1487    emit_2ub(p, 0xdb, 0xf0+arg.idx);
1488    note_x87_pop(p);
1489 }
1490
1491
1492 void x87_fnstsw( struct x86_function *p, struct x86_reg dst )
1493 {
1494    DUMP_R( dst );
1495    assert(dst.file == file_REG32);
1496
1497    if (dst.idx == reg_AX &&
1498        dst.mod == mod_REG)
1499       emit_2ub(p, 0xdf, 0xe0);
1500    else {
1501       emit_1ub(p, 0xdd);
1502       emit_modrm_noreg(p, 7, dst);
1503    }
1504 }
1505
1506
1507 void x87_fnstcw( struct x86_function *p, struct x86_reg dst )
1508 {
1509    DUMP_R( dst );
1510    assert(dst.file == file_REG32);
1511
1512    emit_1ub(p, 0x9b);           /* WAIT -- needed? */
1513    emit_1ub(p, 0xd9);
1514    emit_modrm_noreg(p, 7, dst);
1515 }
1516
1517
1518
1519
1520 /***********************************************************************
1521  * MMX instructions
1522  */
1523
1524 void mmx_emms( struct x86_function *p )
1525 {
1526    DUMP();
1527    assert(p->need_emms);
1528    emit_2ub(p, 0x0f, 0x77);
1529    p->need_emms = 0;
1530 }
1531
1532 void mmx_packssdw( struct x86_function *p,
1533                    struct x86_reg dst,
1534                    struct x86_reg src )
1535 {
1536    DUMP_RR( dst, src );
1537    assert(dst.file == file_MMX &&
1538           (src.file == file_MMX || src.mod != mod_REG));
1539
1540    p->need_emms = 1;
1541
1542    emit_2ub(p, X86_TWOB, 0x6b);
1543    emit_modrm( p, dst, src );
1544 }
1545
1546 void mmx_packuswb( struct x86_function *p,
1547                    struct x86_reg dst,
1548                    struct x86_reg src )
1549 {
1550    DUMP_RR( dst, src );
1551    assert(dst.file == file_MMX &&
1552           (src.file == file_MMX || src.mod != mod_REG));
1553
1554    p->need_emms = 1;
1555
1556    emit_2ub(p, X86_TWOB, 0x67);
1557    emit_modrm( p, dst, src );
1558 }
1559
1560 void mmx_movd( struct x86_function *p,
1561                struct x86_reg dst,
1562                struct x86_reg src )
1563 {
1564    DUMP_RR( dst, src );
1565    p->need_emms = 1;
1566    emit_1ub(p, X86_TWOB);
1567    emit_op_modrm( p, 0x6e, 0x7e, dst, src );
1568 }
1569
1570 void mmx_movq( struct x86_function *p,
1571                struct x86_reg dst,
1572                struct x86_reg src )
1573 {
1574    DUMP_RR( dst, src );
1575    p->need_emms = 1;
1576    emit_1ub(p, X86_TWOB);
1577    emit_op_modrm( p, 0x6f, 0x7f, dst, src );
1578 }
1579
1580
1581 /***********************************************************************
1582  * Helper functions
1583  */
1584
1585
1586 void x86_cdecl_caller_push_regs( struct x86_function *p )
1587 {
1588    x86_push(p, x86_make_reg(file_REG32, reg_AX));
1589    x86_push(p, x86_make_reg(file_REG32, reg_CX));
1590    x86_push(p, x86_make_reg(file_REG32, reg_DX));
1591 }
1592
1593 void x86_cdecl_caller_pop_regs( struct x86_function *p )
1594 {
1595    x86_pop(p, x86_make_reg(file_REG32, reg_DX));
1596    x86_pop(p, x86_make_reg(file_REG32, reg_CX));
1597    x86_pop(p, x86_make_reg(file_REG32, reg_AX));
1598 }
1599
1600
1601 /* Retreive a reference to one of the function arguments, taking into
1602  * account any push/pop activity:
1603  */
1604 struct x86_reg x86_fn_arg( struct x86_function *p,
1605                            unsigned arg )
1606 {
1607    return x86_make_disp(x86_make_reg(file_REG32, reg_SP),
1608                         p->stack_offset + arg * 4);     /* ??? */
1609 }
1610
1611
1612 void x86_init_func( struct x86_function *p )
1613 {
1614    p->size = 0;
1615    p->store = NULL;
1616    p->csr = p->store;
1617    DUMP_START();
1618 }
1619
1620 void x86_init_func_size( struct x86_function *p, unsigned code_size )
1621 {
1622    p->size = code_size;
1623    p->store = rtasm_exec_malloc(code_size);
1624    if (p->store == NULL) {
1625       p->store = p->error_overflow;
1626    }
1627    p->csr = p->store;
1628    DUMP_START();
1629 }
1630
1631 void x86_release_func( struct x86_function *p )
1632 {
1633    if (p->store && p->store != p->error_overflow)
1634       rtasm_exec_free(p->store);
1635
1636    p->store = NULL;
1637    p->csr = NULL;
1638    p->size = 0;
1639 }
1640
1641
1642 void (*x86_get_func( struct x86_function *p ))(void)
1643 {
1644    DUMP_END();
1645    if (DISASSEM && p->store)
1646       debug_printf("disassemble %p %p\n", p->store, p->csr);
1647
1648    if (p->store == p->error_overflow)
1649       return (void (*)(void)) NULL;
1650    else
1651       return (void (*)(void)) p->store;
1652 }
1653
1654 #else
1655
1656 void x86sse_dummy( void )
1657 {
1658 }
1659
1660 #endif