projects / mesa.git / blob
? search:


9085f4cc0e722661256907ff8d034159bb597b24
[mesa.git] / 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 void sse_prefetchnta( struct x86_function *p, struct x86_reg ptr)
633 {
634 DUMP_R( ptr );
635 assert(ptr.mod != mod_REG);
636 emit_2ub(p, 0x0f, 0x18);
637 emit_modrm_noreg(p, 0, ptr);
638 }
639
640 void sse_prefetch0( struct x86_function *p, struct x86_reg ptr)
641 {
642 DUMP_R( ptr );
643 assert(ptr.mod != mod_REG);
644 emit_2ub(p, 0x0f, 0x18);
645 emit_modrm_noreg(p, 1, ptr);
646 }
647
648 void sse_prefetch1( struct x86_function *p, struct x86_reg ptr)
649 {
650 DUMP_R( ptr );
651 assert(ptr.mod != mod_REG);
652 emit_2ub(p, 0x0f, 0x18);
653 emit_modrm_noreg(p, 2, ptr);
654 }
655
656
657
658
659 void sse_movss( struct x86_function *p,
660 struct x86_reg dst,
661 struct x86_reg src )
662 {
663 DUMP_RR( dst, src );
664 emit_2ub(p, 0xF3, X86_TWOB);
665 emit_op_modrm( p, 0x10, 0x11, dst, src );
666 }
667
668 void sse_movaps( struct x86_function *p,
669 struct x86_reg dst,
670 struct x86_reg src )
671 {
672 DUMP_RR( dst, src );
673 emit_1ub(p, X86_TWOB);
674 emit_op_modrm( p, 0x28, 0x29, dst, src );
675 }
676
677 void sse_movups( struct x86_function *p,
678 struct x86_reg dst,
679 struct x86_reg src )
680 {
681 DUMP_RR( dst, src );
682 emit_1ub(p, X86_TWOB);
683 emit_op_modrm( p, 0x10, 0x11, dst, src );
684 }
685
686 void sse_movhps( struct x86_function *p,
687 struct x86_reg dst,
688 struct x86_reg src )
689 {
690 DUMP_RR( dst, src );
691 assert(dst.mod != mod_REG || src.mod != mod_REG);
692 emit_1ub(p, X86_TWOB);
693 emit_op_modrm( p, 0x16, 0x17, dst, src ); /* cf movlhps */
694 }
695
696 void sse_movlps( struct x86_function *p,
697 struct x86_reg dst,
698 struct x86_reg src )
699 {
700 DUMP_RR( dst, src );
701 assert(dst.mod != mod_REG || src.mod != mod_REG);
702 emit_1ub(p, X86_TWOB);
703 emit_op_modrm( p, 0x12, 0x13, dst, src ); /* cf movhlps */
704 }
705
706 void sse_maxps( struct x86_function *p,
707 struct x86_reg dst,
708 struct x86_reg src )
709 {
710 DUMP_RR( dst, src );
711 emit_2ub(p, X86_TWOB, 0x5F);
712 emit_modrm( p, dst, src );
713 }
714
715 void sse_maxss( struct x86_function *p,
716 struct x86_reg dst,
717 struct x86_reg src )
718 {
719 DUMP_RR( dst, src );
720 emit_3ub(p, 0xF3, X86_TWOB, 0x5F);
721 emit_modrm( p, dst, src );
722 }
723
724 void sse_divss( struct x86_function *p,
725 struct x86_reg dst,
726 struct x86_reg src )
727 {
728 DUMP_RR( dst, src );
729 emit_3ub(p, 0xF3, X86_TWOB, 0x5E);
730 emit_modrm( p, dst, src );
731 }
732
733 void sse_minps( struct x86_function *p,
734 struct x86_reg dst,
735 struct x86_reg src )
736 {
737 DUMP_RR( dst, src );
738 emit_2ub(p, X86_TWOB, 0x5D);
739 emit_modrm( p, dst, src );
740 }
741
742 void sse_subps( struct x86_function *p,
743 struct x86_reg dst,
744 struct x86_reg src )
745 {
746 DUMP_RR( dst, src );
747 emit_2ub(p, X86_TWOB, 0x5C);
748 emit_modrm( p, dst, src );
749 }
750
751 void sse_mulps( struct x86_function *p,
752 struct x86_reg dst,
753 struct x86_reg src )
754 {
755 DUMP_RR( dst, src );
756 emit_2ub(p, X86_TWOB, 0x59);
757 emit_modrm( p, dst, src );
758 }
759
760 void sse_mulss( struct x86_function *p,
761 struct x86_reg dst,
762 struct x86_reg src )
763 {
764 DUMP_RR( dst, src );
765 emit_3ub(p, 0xF3, X86_TWOB, 0x59);
766 emit_modrm( p, dst, src );
767 }
768
769 void sse_addps( struct x86_function *p,
770 struct x86_reg dst,
771 struct x86_reg src )
772 {
773 DUMP_RR( dst, src );
774 emit_2ub(p, X86_TWOB, 0x58);
775 emit_modrm( p, dst, src );
776 }
777
778 void sse_addss( struct x86_function *p,
779 struct x86_reg dst,
780 struct x86_reg src )
781 {
782 DUMP_RR( dst, src );
783 emit_3ub(p, 0xF3, X86_TWOB, 0x58);
784 emit_modrm( p, dst, src );
785 }
786
787 void sse_andnps( struct x86_function *p,
788 struct x86_reg dst,
789 struct x86_reg src )
790 {
791 DUMP_RR( dst, src );
792 emit_2ub(p, X86_TWOB, 0x55);
793 emit_modrm( p, dst, src );
794 }
795
796 void sse_andps( struct x86_function *p,
797 struct x86_reg dst,
798 struct x86_reg src )
799 {
800 DUMP_RR( dst, src );
801 emit_2ub(p, X86_TWOB, 0x54);
802 emit_modrm( p, dst, src );
803 }
804
805 void sse_rsqrtps( struct x86_function *p,
806 struct x86_reg dst,
807 struct x86_reg src )
808 {
809 DUMP_RR( dst, src );
810 emit_2ub(p, X86_TWOB, 0x52);
811 emit_modrm( p, dst, src );
812 }
813
814 void sse_rsqrtss( struct x86_function *p,
815 struct x86_reg dst,
816 struct x86_reg src )
817 {
818 DUMP_RR( dst, src );
819 emit_3ub(p, 0xF3, X86_TWOB, 0x52);
820 emit_modrm( p, dst, src );
821
822 }
823
824 void sse_movhlps( struct x86_function *p,
825 struct x86_reg dst,
826 struct x86_reg src )
827 {
828 DUMP_RR( dst, src );
829 assert(dst.mod == mod_REG && src.mod == mod_REG);
830 emit_2ub(p, X86_TWOB, 0x12);
831 emit_modrm( p, dst, src );
832 }
833
834 void sse_movlhps( struct x86_function *p,
835 struct x86_reg dst,
836 struct x86_reg src )
837 {
838 DUMP_RR( dst, src );
839 assert(dst.mod == mod_REG && src.mod == mod_REG);
840 emit_2ub(p, X86_TWOB, 0x16);
841 emit_modrm( p, dst, src );
842 }
843
844 void sse_orps( struct x86_function *p,
845 struct x86_reg dst,
846 struct x86_reg src )
847 {
848 DUMP_RR( dst, src );
849 emit_2ub(p, X86_TWOB, 0x56);
850 emit_modrm( p, dst, src );
851 }
852
853 void sse_xorps( struct x86_function *p,
854 struct x86_reg dst,
855 struct x86_reg src )
856 {
857 DUMP_RR( dst, src );
858 emit_2ub(p, X86_TWOB, 0x57);
859 emit_modrm( p, dst, src );
860 }
861
862 void sse_cvtps2pi( struct x86_function *p,
863 struct x86_reg dst,
864 struct x86_reg src )
865 {
866 DUMP_RR( dst, src );
867 assert(dst.file == file_MMX &&
868 (src.file == file_XMM || src.mod != mod_REG));
869
870 p->need_emms = 1;
871
872 emit_2ub(p, X86_TWOB, 0x2d);
873 emit_modrm( p, dst, src );
874 }
875
876 void sse2_cvtdq2ps( struct x86_function *p,
877 struct x86_reg dst,
878 struct x86_reg src )
879 {
880 DUMP_RR( dst, src );
881 emit_2ub(p, X86_TWOB, 0x5b);
882 emit_modrm( p, dst, src );
883 }
884
885
886 /* Shufps can also be used to implement a reduced swizzle when dest ==
887 * arg0.
888 */
889 void sse_shufps( struct x86_function *p,
890 struct x86_reg dst,
891 struct x86_reg src,
892 unsigned char shuf)
893 {
894 DUMP_RRI( dst, src, shuf );
895 emit_2ub(p, X86_TWOB, 0xC6);
896 emit_modrm(p, dst, src);
897 emit_1ub(p, shuf);
898 }
899
900 void sse_unpckhps( struct x86_function *p, struct x86_reg dst, struct x86_reg src )
901 {
902 DUMP_RR( dst, src );
903 emit_2ub( p, X86_TWOB, 0x15 );
904 emit_modrm( p, dst, src );
905 }
906
907 void sse_unpcklps( struct x86_function *p, struct x86_reg dst, struct x86_reg src )
908 {
909 DUMP_RR( dst, src );
910 emit_2ub( p, X86_TWOB, 0x14 );
911 emit_modrm( p, dst, src );
912 }
913
914 void sse_cmpps( struct x86_function *p,
915 struct x86_reg dst,
916 struct x86_reg src,
917 enum sse_cc cc)
918 {
919 DUMP_RRI( dst, src, cc );
920 emit_2ub(p, X86_TWOB, 0xC2);
921 emit_modrm(p, dst, src);
922 emit_1ub(p, cc);
923 }
924
925 void sse_pmovmskb( struct x86_function *p,
926 struct x86_reg dst,
927 struct x86_reg src)
928 {
929 DUMP_RR( dst, src );
930 emit_3ub(p, 0x66, X86_TWOB, 0xD7);
931 emit_modrm(p, dst, src);
932 }
933
934 /***********************************************************************
935 * SSE2 instructions
936 */
937
938 /**
939 * Perform a reduced swizzle:
940 */
941 void sse2_pshufd( struct x86_function *p,
942 struct x86_reg dst,
943 struct x86_reg src,
944 unsigned char shuf)
945 {
946 DUMP_RRI( dst, src, shuf );
947 emit_3ub(p, 0x66, X86_TWOB, 0x70);
948 emit_modrm(p, dst, src);
949 emit_1ub(p, shuf);
950 }
951
952 void sse2_cvttps2dq( struct x86_function *p,
953 struct x86_reg dst,
954 struct x86_reg src )
955 {
956 DUMP_RR( dst, src );
957 emit_3ub( p, 0xF3, X86_TWOB, 0x5B );
958 emit_modrm( p, dst, src );
959 }
960
961 void sse2_cvtps2dq( struct x86_function *p,
962 struct x86_reg dst,
963 struct x86_reg src )
964 {
965 DUMP_RR( dst, src );
966 emit_3ub(p, 0x66, X86_TWOB, 0x5B);
967 emit_modrm( p, dst, src );
968 }
969
970 void sse2_packssdw( struct x86_function *p,
971 struct x86_reg dst,
972 struct x86_reg src )
973 {
974 DUMP_RR( dst, src );
975 emit_3ub(p, 0x66, X86_TWOB, 0x6B);
976 emit_modrm( p, dst, src );
977 }
978
979 void sse2_packsswb( struct x86_function *p,
980 struct x86_reg dst,
981 struct x86_reg src )
982 {
983 DUMP_RR( dst, src );
984 emit_3ub(p, 0x66, X86_TWOB, 0x63);
985 emit_modrm( p, dst, src );
986 }
987
988 void sse2_packuswb( struct x86_function *p,
989 struct x86_reg dst,
990 struct x86_reg src )
991 {
992 DUMP_RR( dst, src );
993 emit_3ub(p, 0x66, X86_TWOB, 0x67);
994 emit_modrm( p, dst, src );
995 }
996
997 void sse2_punpcklbw( struct x86_function *p,
998 struct x86_reg dst,
999 struct x86_reg src )
1000 {
1001 DUMP_RR( dst, src );
1002 emit_3ub(p, 0x66, X86_TWOB, 0x60);
1003 emit_modrm( p, dst, src );
1004 }
1005
1006
1007 void sse2_rcpps( struct x86_function *p,
1008 struct x86_reg dst,
1009 struct x86_reg src )
1010 {
1011 DUMP_RR( dst, src );
1012 emit_2ub(p, X86_TWOB, 0x53);
1013 emit_modrm( p, dst, src );
1014 }
1015
1016 void sse2_rcpss( struct x86_function *p,
1017 struct x86_reg dst,
1018 struct x86_reg src )
1019 {
1020 DUMP_RR( dst, src );
1021 emit_3ub(p, 0xF3, X86_TWOB, 0x53);
1022 emit_modrm( p, dst, src );
1023 }
1024
1025 void sse2_movd( struct x86_function *p,
1026 struct x86_reg dst,
1027 struct x86_reg src )
1028 {
1029 DUMP_RR( dst, src );
1030 emit_2ub(p, 0x66, X86_TWOB);
1031 emit_op_modrm( p, 0x6e, 0x7e, dst, src );
1032 }
1033
1034
1035
1036
1037 /***********************************************************************
1038 * x87 instructions
1039 */
1040 static void note_x87_pop( struct x86_function *p )
1041 {
1042 p->x87_stack--;
1043 assert(p->x87_stack >= 0);
1044 }
1045
1046 static void note_x87_push( struct x86_function *p )
1047 {
1048 p->x87_stack++;
1049 assert(p->x87_stack <= 7);
1050 }
1051
1052 void x87_assert_stack_empty( struct x86_function *p )
1053 {
1054 assert (p->x87_stack == 0);
1055 }
1056
1057
1058 void x87_fist( struct x86_function *p, struct x86_reg dst )
1059 {
1060 DUMP_R( dst );
1061 emit_1ub(p, 0xdb);
1062 emit_modrm_noreg(p, 2, dst);
1063 }
1064
1065 void x87_fistp( struct x86_function *p, struct x86_reg dst )
1066 {
1067 DUMP_R( dst );
1068 emit_1ub(p, 0xdb);
1069 emit_modrm_noreg(p, 3, dst);
1070 note_x87_pop(p);
1071 }
1072
1073 void x87_fild( struct x86_function *p, struct x86_reg arg )
1074 {
1075 DUMP_R( arg );
1076 emit_1ub(p, 0xdf);
1077 emit_modrm_noreg(p, 0, arg);
1078 note_x87_push(p);
1079 }
1080
1081 void x87_fldz( struct x86_function *p )
1082 {
1083 DUMP();
1084 emit_2ub(p, 0xd9, 0xee);
1085 note_x87_push(p);
1086 }
1087
1088
1089 void x87_fldcw( struct x86_function *p, struct x86_reg arg )
1090 {
1091 DUMP_R( arg );
1092 assert(arg.file == file_REG32);
1093 assert(arg.mod != mod_REG);
1094 emit_1ub(p, 0xd9);
1095 emit_modrm_noreg(p, 5, arg);
1096 }
1097
1098 void x87_fld1( struct x86_function *p )
1099 {
1100 DUMP();
1101 emit_2ub(p, 0xd9, 0xe8);
1102 note_x87_push(p);
1103 }
1104
1105 void x87_fldl2e( struct x86_function *p )
1106 {
1107 DUMP();
1108 emit_2ub(p, 0xd9, 0xea);
1109 note_x87_push(p);
1110 }
1111
1112 void x87_fldln2( struct x86_function *p )
1113 {
1114 DUMP();
1115 emit_2ub(p, 0xd9, 0xed);
1116 note_x87_push(p);
1117 }
1118
1119 void x87_fwait( struct x86_function *p )
1120 {
1121 DUMP();
1122 emit_1ub(p, 0x9b);
1123 }
1124
1125 void x87_fnclex( struct x86_function *p )
1126 {
1127 DUMP();
1128 emit_2ub(p, 0xdb, 0xe2);
1129 }
1130
1131 void x87_fclex( struct x86_function *p )
1132 {
1133 x87_fwait(p);
1134 x87_fnclex(p);
1135 }
1136
1137 void x87_fcmovb( struct x86_function *p, struct x86_reg arg )
1138 {
1139 DUMP_R( arg );
1140 assert(arg.file == file_x87);
1141 emit_2ub(p, 0xda, 0xc0+arg.idx);
1142 }
1143
1144 void x87_fcmove( struct x86_function *p, struct x86_reg arg )
1145 {
1146 DUMP_R( arg );
1147 assert(arg.file == file_x87);
1148 emit_2ub(p, 0xda, 0xc8+arg.idx);
1149 }
1150
1151 void x87_fcmovbe( struct x86_function *p, struct x86_reg arg )
1152 {
1153 DUMP_R( arg );
1154 assert(arg.file == file_x87);
1155 emit_2ub(p, 0xda, 0xd0+arg.idx);
1156 }
1157
1158 void x87_fcmovnb( struct x86_function *p, struct x86_reg arg )
1159 {
1160 DUMP_R( arg );
1161 assert(arg.file == file_x87);
1162 emit_2ub(p, 0xdb, 0xc0+arg.idx);
1163 }
1164
1165 void x87_fcmovne( struct x86_function *p, struct x86_reg arg )
1166 {
1167 DUMP_R( arg );
1168 assert(arg.file == file_x87);
1169 emit_2ub(p, 0xdb, 0xc8+arg.idx);
1170 }
1171
1172 void x87_fcmovnbe( struct x86_function *p, struct x86_reg arg )
1173 {
1174 DUMP_R( arg );
1175 assert(arg.file == file_x87);
1176 emit_2ub(p, 0xdb, 0xd0+arg.idx);
1177 }
1178
1179
1180
1181 static void x87_arith_op( struct x86_function *p, struct x86_reg dst, struct x86_reg arg,
1182 unsigned char dst0ub0,
1183 unsigned char dst0ub1,
1184 unsigned char arg0ub0,
1185 unsigned char arg0ub1,
1186 unsigned char argmem_noreg)
1187 {
1188 assert(dst.file == file_x87);
1189
1190 if (arg.file == file_x87) {
1191 if (dst.idx == 0)
1192 emit_2ub(p, dst0ub0, dst0ub1+arg.idx);
1193 else if (arg.idx == 0)
1194 emit_2ub(p, arg0ub0, arg0ub1+arg.idx);
1195 else
1196 assert(0);
1197 }
1198 else if (dst.idx == 0) {
1199 assert(arg.file == file_REG32);
1200 emit_1ub(p, 0xd8);
1201 emit_modrm_noreg(p, argmem_noreg, arg);
1202 }
1203 else
1204 assert(0);
1205 }
1206
1207 void x87_fmul( struct x86_function *p, struct x86_reg dst, struct x86_reg src )
1208 {
1209 DUMP_RR( dst, src );
1210 x87_arith_op(p, dst, src,
1211 0xd8, 0xc8,
1212 0xdc, 0xc8,
1213 4);
1214 }
1215
1216 void x87_fsub( struct x86_function *p, struct x86_reg dst, struct x86_reg src )
1217 {
1218 DUMP_RR( dst, src );
1219 x87_arith_op(p, dst, src,
1220 0xd8, 0xe0,
1221 0xdc, 0xe8,
1222 4);
1223 }
1224
1225 void x87_fsubr( struct x86_function *p, struct x86_reg dst, struct x86_reg src )
1226 {
1227 DUMP_RR( dst, src );
1228 x87_arith_op(p, dst, src,
1229 0xd8, 0xe8,
1230 0xdc, 0xe0,
1231 5);
1232 }
1233
1234 void x87_fadd( struct x86_function *p, struct x86_reg dst, struct x86_reg src )
1235 {
1236 DUMP_RR( dst, src );
1237 x87_arith_op(p, dst, src,
1238 0xd8, 0xc0,
1239 0xdc, 0xc0,
1240 0);
1241 }
1242
1243 void x87_fdiv( struct x86_function *p, struct x86_reg dst, struct x86_reg src )
1244 {
1245 DUMP_RR( dst, src );
1246 x87_arith_op(p, dst, src,
1247 0xd8, 0xf0,
1248 0xdc, 0xf8,
1249 6);
1250 }
1251
1252 void x87_fdivr( struct x86_function *p, struct x86_reg dst, struct x86_reg src )
1253 {
1254 DUMP_RR( dst, src );
1255 x87_arith_op(p, dst, src,
1256 0xd8, 0xf8,
1257 0xdc, 0xf0,
1258 7);
1259 }
1260
1261 void x87_fmulp( struct x86_function *p, struct x86_reg dst )
1262 {
1263 DUMP_R( dst );
1264 assert(dst.file == file_x87);
1265 assert(dst.idx >= 1);
1266 emit_2ub(p, 0xde, 0xc8+dst.idx);
1267 note_x87_pop(p);
1268 }
1269
1270 void x87_fsubp( struct x86_function *p, struct x86_reg dst )
1271 {
1272 DUMP_R( dst );
1273 assert(dst.file == file_x87);
1274 assert(dst.idx >= 1);
1275 emit_2ub(p, 0xde, 0xe8+dst.idx);
1276 note_x87_pop(p);
1277 }
1278
1279 void x87_fsubrp( struct x86_function *p, struct x86_reg dst )
1280 {
1281 DUMP_R( dst );
1282 assert(dst.file == file_x87);
1283 assert(dst.idx >= 1);
1284 emit_2ub(p, 0xde, 0xe0+dst.idx);
1285 note_x87_pop(p);
1286 }
1287
1288 void x87_faddp( struct x86_function *p, struct x86_reg dst )
1289 {
1290 DUMP_R( dst );
1291 assert(dst.file == file_x87);
1292 assert(dst.idx >= 1);
1293 emit_2ub(p, 0xde, 0xc0+dst.idx);
1294 note_x87_pop(p);
1295 }
1296
1297 void x87_fdivp( struct x86_function *p, struct x86_reg dst )
1298 {
1299 DUMP_R( dst );
1300 assert(dst.file == file_x87);
1301 assert(dst.idx >= 1);
1302 emit_2ub(p, 0xde, 0xf8+dst.idx);
1303 note_x87_pop(p);
1304 }
1305
1306 void x87_fdivrp( struct x86_function *p, struct x86_reg dst )
1307 {
1308 DUMP_R( dst );
1309 assert(dst.file == file_x87);
1310 assert(dst.idx >= 1);
1311 emit_2ub(p, 0xde, 0xf0+dst.idx);
1312 note_x87_pop(p);
1313 }
1314
1315 void x87_ftst( struct x86_function *p )
1316 {
1317 DUMP();
1318 emit_2ub(p, 0xd9, 0xe4);
1319 }
1320
1321 void x87_fucom( struct x86_function *p, struct x86_reg arg )
1322 {
1323 DUMP_R( arg );
1324 assert(arg.file == file_x87);
1325 emit_2ub(p, 0xdd, 0xe0+arg.idx);
1326 }
1327
1328 void x87_fucomp( struct x86_function *p, struct x86_reg arg )
1329 {
1330 DUMP_R( arg );
1331 assert(arg.file == file_x87);
1332 emit_2ub(p, 0xdd, 0xe8+arg.idx);
1333 note_x87_pop(p);
1334 }
1335
1336 void x87_fucompp( struct x86_function *p )
1337 {
1338 DUMP();
1339 emit_2ub(p, 0xda, 0xe9);
1340 note_x87_pop(p); /* pop twice */
1341 note_x87_pop(p); /* pop twice */
1342 }
1343
1344 void x87_fxch( struct x86_function *p, struct x86_reg arg )
1345 {
1346 DUMP_R( arg );
1347 assert(arg.file == file_x87);
1348 emit_2ub(p, 0xd9, 0xc8+arg.idx);
1349 }
1350
1351 void x87_fabs( struct x86_function *p )
1352 {
1353 DUMP();
1354 emit_2ub(p, 0xd9, 0xe1);
1355 }
1356
1357 void x87_fchs( struct x86_function *p )
1358 {
1359 DUMP();
1360 emit_2ub(p, 0xd9, 0xe0);
1361 }
1362
1363 void x87_fcos( struct x86_function *p )
1364 {
1365 DUMP();
1366 emit_2ub(p, 0xd9, 0xff);
1367 }
1368
1369
1370 void x87_fprndint( struct x86_function *p )
1371 {
1372 DUMP();
1373 emit_2ub(p, 0xd9, 0xfc);
1374 }
1375
1376 void x87_fscale( struct x86_function *p )
1377 {
1378 DUMP();
1379 emit_2ub(p, 0xd9, 0xfd);
1380 }
1381
1382 void x87_fsin( struct x86_function *p )
1383 {
1384 DUMP();
1385 emit_2ub(p, 0xd9, 0xfe);
1386 }
1387
1388 void x87_fsincos( struct x86_function *p )
1389 {
1390 DUMP();
1391 emit_2ub(p, 0xd9, 0xfb);
1392 }
1393
1394 void x87_fsqrt( struct x86_function *p )
1395 {
1396 DUMP();
1397 emit_2ub(p, 0xd9, 0xfa);
1398 }
1399
1400 void x87_fxtract( struct x86_function *p )
1401 {
1402 DUMP();
1403 emit_2ub(p, 0xd9, 0xf4);
1404 }
1405
1406 /* st0 = (2^st0)-1
1407 *
1408 * Restrictions: -1.0 <= st0 <= 1.0
1409 */
1410 void x87_f2xm1( struct x86_function *p )
1411 {
1412 DUMP();
1413 emit_2ub(p, 0xd9, 0xf0);
1414 }
1415
1416 /* st1 = st1 * log2(st0);
1417 * pop_stack;
1418 */
1419 void x87_fyl2x( struct x86_function *p )
1420 {
1421 DUMP();
1422 emit_2ub(p, 0xd9, 0xf1);
1423 note_x87_pop(p);
1424 }
1425
1426 /* st1 = st1 * log2(st0 + 1.0);
1427 * pop_stack;
1428 *
1429 * A fast operation, with restrictions: -.29 < st0 < .29
1430 */
1431 void x87_fyl2xp1( struct x86_function *p )
1432 {
1433 DUMP();
1434 emit_2ub(p, 0xd9, 0xf9);
1435 note_x87_pop(p);
1436 }
1437
1438
1439 void x87_fld( struct x86_function *p, struct x86_reg arg )
1440 {
1441 DUMP_R( arg );
1442 if (arg.file == file_x87)
1443 emit_2ub(p, 0xd9, 0xc0 + arg.idx);
1444 else {
1445 emit_1ub(p, 0xd9);
1446 emit_modrm_noreg(p, 0, arg);
1447 }
1448 note_x87_push(p);
1449 }
1450
1451 void x87_fst( struct x86_function *p, struct x86_reg dst )
1452 {
1453 DUMP_R( dst );
1454 if (dst.file == file_x87)
1455 emit_2ub(p, 0xdd, 0xd0 + dst.idx);
1456 else {
1457 emit_1ub(p, 0xd9);
1458 emit_modrm_noreg(p, 2, dst);
1459 }
1460 }
1461
1462 void x87_fstp( struct x86_function *p, struct x86_reg dst )
1463 {
1464 DUMP_R( dst );
1465 if (dst.file == file_x87)
1466 emit_2ub(p, 0xdd, 0xd8 + dst.idx);
1467 else {
1468 emit_1ub(p, 0xd9);
1469 emit_modrm_noreg(p, 3, dst);
1470 }
1471 note_x87_pop(p);
1472 }
1473
1474 void x87_fpop( struct x86_function *p )
1475 {
1476 x87_fstp( p, x86_make_reg( file_x87, 0 ));
1477 }
1478
1479
1480 void x87_fcom( struct x86_function *p, struct x86_reg dst )
1481 {
1482 DUMP_R( dst );
1483 if (dst.file == file_x87)
1484 emit_2ub(p, 0xd8, 0xd0 + dst.idx);
1485 else {
1486 emit_1ub(p, 0xd8);
1487 emit_modrm_noreg(p, 2, dst);
1488 }
1489 }
1490
1491
1492 void x87_fcomp( struct x86_function *p, struct x86_reg dst )
1493 {
1494 DUMP_R( dst );
1495 if (dst.file == file_x87)
1496 emit_2ub(p, 0xd8, 0xd8 + dst.idx);
1497 else {
1498 emit_1ub(p, 0xd8);
1499 emit_modrm_noreg(p, 3, dst);
1500 }
1501 note_x87_pop(p);
1502 }
1503
1504 void x87_fcomi( struct x86_function *p, struct x86_reg arg )
1505 {
1506 DUMP_R( arg );
1507 emit_2ub(p, 0xdb, 0xf0+arg.idx);
1508 }
1509
1510 void x87_fcomip( struct x86_function *p, struct x86_reg arg )
1511 {
1512 DUMP_R( arg );
1513 emit_2ub(p, 0xdb, 0xf0+arg.idx);
1514 note_x87_pop(p);
1515 }
1516
1517
1518 void x87_fnstsw( struct x86_function *p, struct x86_reg dst )
1519 {
1520 DUMP_R( dst );
1521 assert(dst.file == file_REG32);
1522
1523 if (dst.idx == reg_AX &&
1524 dst.mod == mod_REG)
1525 emit_2ub(p, 0xdf, 0xe0);
1526 else {
1527 emit_1ub(p, 0xdd);
1528 emit_modrm_noreg(p, 7, dst);
1529 }
1530 }
1531
1532
1533 void x87_fnstcw( struct x86_function *p, struct x86_reg dst )
1534 {
1535 DUMP_R( dst );
1536 assert(dst.file == file_REG32);
1537
1538 emit_1ub(p, 0x9b); /* WAIT -- needed? */
1539 emit_1ub(p, 0xd9);
1540 emit_modrm_noreg(p, 7, dst);
1541 }
1542
1543
1544
1545
1546 /***********************************************************************
1547 * MMX instructions
1548 */
1549
1550 void mmx_emms( struct x86_function *p )
1551 {
1552 DUMP();
1553 assert(p->need_emms);
1554 emit_2ub(p, 0x0f, 0x77);
1555 p->need_emms = 0;
1556 }
1557
1558 void mmx_packssdw( struct x86_function *p,
1559 struct x86_reg dst,
1560 struct x86_reg src )
1561 {
1562 DUMP_RR( dst, src );
1563 assert(dst.file == file_MMX &&
1564 (src.file == file_MMX || src.mod != mod_REG));
1565
1566 p->need_emms = 1;
1567
1568 emit_2ub(p, X86_TWOB, 0x6b);
1569 emit_modrm( p, dst, src );
1570 }
1571
1572 void mmx_packuswb( struct x86_function *p,
1573 struct x86_reg dst,
1574 struct x86_reg src )
1575 {
1576 DUMP_RR( dst, src );
1577 assert(dst.file == file_MMX &&
1578 (src.file == file_MMX || src.mod != mod_REG));
1579
1580 p->need_emms = 1;
1581
1582 emit_2ub(p, X86_TWOB, 0x67);
1583 emit_modrm( p, dst, src );
1584 }
1585
1586 void mmx_movd( struct x86_function *p,
1587 struct x86_reg dst,
1588 struct x86_reg src )
1589 {
1590 DUMP_RR( dst, src );
1591 p->need_emms = 1;
1592 emit_1ub(p, X86_TWOB);
1593 emit_op_modrm( p, 0x6e, 0x7e, dst, src );
1594 }
1595
1596 void mmx_movq( struct x86_function *p,
1597 struct x86_reg dst,
1598 struct x86_reg src )
1599 {
1600 DUMP_RR( dst, src );
1601 p->need_emms = 1;
1602 emit_1ub(p, X86_TWOB);
1603 emit_op_modrm( p, 0x6f, 0x7f, dst, src );
1604 }
1605
1606
1607 /***********************************************************************
1608 * Helper functions
1609 */
1610
1611
1612 void x86_cdecl_caller_push_regs( struct x86_function *p )
1613 {
1614 x86_push(p, x86_make_reg(file_REG32, reg_AX));
1615 x86_push(p, x86_make_reg(file_REG32, reg_CX));
1616 x86_push(p, x86_make_reg(file_REG32, reg_DX));
1617 }
1618
1619 void x86_cdecl_caller_pop_regs( struct x86_function *p )
1620 {
1621 x86_pop(p, x86_make_reg(file_REG32, reg_DX));
1622 x86_pop(p, x86_make_reg(file_REG32, reg_CX));
1623 x86_pop(p, x86_make_reg(file_REG32, reg_AX));
1624 }
1625
1626
1627 /* Retreive a reference to one of the function arguments, taking into
1628 * account any push/pop activity:
1629 */
1630 struct x86_reg x86_fn_arg( struct x86_function *p,
1631 unsigned arg )
1632 {
1633 return x86_make_disp(x86_make_reg(file_REG32, reg_SP),
1634 p->stack_offset + arg * 4); /* ??? */
1635 }
1636
1637
1638 void x86_init_func( struct x86_function *p )
1639 {
1640 p->size = 0;
1641 p->store = NULL;
1642 p->csr = p->store;
1643 DUMP_START();
1644 }
1645
1646 void x86_init_func_size( struct x86_function *p, unsigned code_size )
1647 {
1648 p->size = code_size;
1649 p->store = rtasm_exec_malloc(code_size);
1650 if (p->store == NULL) {
1651 p->store = p->error_overflow;
1652 }
1653 p->csr = p->store;
1654 DUMP_START();
1655 }
1656
1657 void x86_release_func( struct x86_function *p )
1658 {
1659 if (p->store && p->store != p->error_overflow)
1660 rtasm_exec_free(p->store);
1661
1662 p->store = NULL;
1663 p->csr = NULL;
1664 p->size = 0;
1665 }
1666
1667
1668 void (*x86_get_func( struct x86_function *p ))(void)
1669 {
1670 DUMP_END();
1671 if (DISASSEM && p->store)
1672 debug_printf("disassemble %p %p\n", p->store, p->csr);
1673
1674 if (p->store == p->error_overflow)
1675 return (void (*)(void)) NULL;
1676 else
1677 return (void (*)(void)) p->store;
1678 }
1679
1680 #else
1681
1682 void x86sse_dummy( void )
1683 {
1684 }
1685
1686 #endif