repositories / deb_xorg-server.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Imported Upstream version 1.15.1
[deb_xorg-server.git] / hw / xfree86 / x86emu / x86emu / prim_asm.h
1 /****************************************************************************
2 *
3 * Realmode X86 Emulator Library
4 *
5 * Copyright (C) 1996-1999 SciTech Software, Inc.
6 * Copyright (C) David Mosberger-Tang
7 * Copyright (C) 1999 Egbert Eich
8 *
9 * ========================================================================
10 *
11 * Permission to use, copy, modify, distribute, and sell this software and
12 * its documentation for any purpose is hereby granted without fee,
13 * provided that the above copyright notice appear in all copies and that
14 * both that copyright notice and this permission notice appear in
15 * supporting documentation, and that the name of the authors not be used
16 * in advertising or publicity pertaining to distribution of the software
17 * without specific, written prior permission. The authors makes no
18 * representations about the suitability of this software for any purpose.
19 * It is provided "as is" without express or implied warranty.
20 *
21 * THE AUTHORS DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
22 * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
23 * EVENT SHALL THE AUTHORS BE LIABLE FOR ANY SPECIAL, INDIRECT OR
24 * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF
25 * USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
26 * OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
27 * PERFORMANCE OF THIS SOFTWARE.
28 *
29 * ========================================================================
30 *
31 * Language: Watcom C++ 10.6 or later
32 * Environment: Any
33 * Developer: Kendall Bennett
34 *
35 * Description: Inline assembler versions of the primitive operand
36 * functions for faster performance. At the moment this is
37 * x86 inline assembler, but these functions could be replaced
38 * with native inline assembler for each supported processor
39 * platform.
40 *
41 ****************************************************************************/
42
43 #ifndef __X86EMU_PRIM_ASM_H
44 #define __X86EMU_PRIM_ASM_H
45
46 #ifdef __WATCOMC__
47
48 #ifndef VALIDATE
49 #define __HAVE_INLINE_ASSEMBLER__
50 #endif
51
52 u32 get_flags_asm(void);
53
54 #pragma aux get_flags_asm = \
55 "pushf" \
56 "pop eax" \
57 value [eax] \
58 modify exact [eax];
59
60 u16 aaa_word_asm(u32 * flags, u16 d);
61
62 #pragma aux aaa_word_asm = \
63 "push [edi]" \
64 "popf" \
65 "aaa" \
66 "pushf" \
67 "pop [edi]" \
68 parm [edi] [ax] \
69 value [ax] \
70 modify exact [ax];
71
72 u16 aas_word_asm(u32 * flags, u16 d);
73
74 #pragma aux aas_word_asm = \
75 "push [edi]" \
76 "popf" \
77 "aas" \
78 "pushf" \
79 "pop [edi]" \
80 parm [edi] [ax] \
81 value [ax] \
82 modify exact [ax];
83
84 u16 aad_word_asm(u32 * flags, u16 d);
85
86 #pragma aux aad_word_asm = \
87 "push [edi]" \
88 "popf" \
89 "aad" \
90 "pushf" \
91 "pop [edi]" \
92 parm [edi] [ax] \
93 value [ax] \
94 modify exact [ax];
95
96 u16 aam_word_asm(u32 * flags, u8 d);
97
98 #pragma aux aam_word_asm = \
99 "push [edi]" \
100 "popf" \
101 "aam" \
102 "pushf" \
103 "pop [edi]" \
104 parm [edi] [al] \
105 value [ax] \
106 modify exact [ax];
107
108 u8 adc_byte_asm(u32 * flags, u8 d, u8 s);
109
110 #pragma aux adc_byte_asm = \
111 "push [edi]" \
112 "popf" \
113 "adc al,bl" \
114 "pushf" \
115 "pop [edi]" \
116 parm [edi] [al] [bl] \
117 value [al] \
118 modify exact [al bl];
119
120 u16 adc_word_asm(u32 * flags, u16 d, u16 s);
121
122 #pragma aux adc_word_asm = \
123 "push [edi]" \
124 "popf" \
125 "adc ax,bx" \
126 "pushf" \
127 "pop [edi]" \
128 parm [edi] [ax] [bx] \
129 value [ax] \
130 modify exact [ax bx];
131
132 u32 adc_long_asm(u32 * flags, u32 d, u32 s);
133
134 #pragma aux adc_long_asm = \
135 "push [edi]" \
136 "popf" \
137 "adc eax,ebx" \
138 "pushf" \
139 "pop [edi]" \
140 parm [edi] [eax] [ebx] \
141 value [eax] \
142 modify exact [eax ebx];
143
144 u8 add_byte_asm(u32 * flags, u8 d, u8 s);
145
146 #pragma aux add_byte_asm = \
147 "push [edi]" \
148 "popf" \
149 "add al,bl" \
150 "pushf" \
151 "pop [edi]" \
152 parm [edi] [al] [bl] \
153 value [al] \
154 modify exact [al bl];
155
156 u16 add_word_asm(u32 * flags, u16 d, u16 s);
157
158 #pragma aux add_word_asm = \
159 "push [edi]" \
160 "popf" \
161 "add ax,bx" \
162 "pushf" \
163 "pop [edi]" \
164 parm [edi] [ax] [bx] \
165 value [ax] \
166 modify exact [ax bx];
167
168 u32 add_long_asm(u32 * flags, u32 d, u32 s);
169
170 #pragma aux add_long_asm = \
171 "push [edi]" \
172 "popf" \
173 "add eax,ebx" \
174 "pushf" \
175 "pop [edi]" \
176 parm [edi] [eax] [ebx] \
177 value [eax] \
178 modify exact [eax ebx];
179
180 u8 and_byte_asm(u32 * flags, u8 d, u8 s);
181
182 #pragma aux and_byte_asm = \
183 "push [edi]" \
184 "popf" \
185 "and al,bl" \
186 "pushf" \
187 "pop [edi]" \
188 parm [edi] [al] [bl] \
189 value [al] \
190 modify exact [al bl];
191
192 u16 and_word_asm(u32 * flags, u16 d, u16 s);
193
194 #pragma aux and_word_asm = \
195 "push [edi]" \
196 "popf" \
197 "and ax,bx" \
198 "pushf" \
199 "pop [edi]" \
200 parm [edi] [ax] [bx] \
201 value [ax] \
202 modify exact [ax bx];
203
204 u32 and_long_asm(u32 * flags, u32 d, u32 s);
205
206 #pragma aux and_long_asm = \
207 "push [edi]" \
208 "popf" \
209 "and eax,ebx" \
210 "pushf" \
211 "pop [edi]" \
212 parm [edi] [eax] [ebx] \
213 value [eax] \
214 modify exact [eax ebx];
215
216 u8 cmp_byte_asm(u32 * flags, u8 d, u8 s);
217
218 #pragma aux cmp_byte_asm = \
219 "push [edi]" \
220 "popf" \
221 "cmp al,bl" \
222 "pushf" \
223 "pop [edi]" \
224 parm [edi] [al] [bl] \
225 value [al] \
226 modify exact [al bl];
227
228 u16 cmp_word_asm(u32 * flags, u16 d, u16 s);
229
230 #pragma aux cmp_word_asm = \
231 "push [edi]" \
232 "popf" \
233 "cmp ax,bx" \
234 "pushf" \
235 "pop [edi]" \
236 parm [edi] [ax] [bx] \
237 value [ax] \
238 modify exact [ax bx];
239
240 u32 cmp_long_asm(u32 * flags, u32 d, u32 s);
241
242 #pragma aux cmp_long_asm = \
243 "push [edi]" \
244 "popf" \
245 "cmp eax,ebx" \
246 "pushf" \
247 "pop [edi]" \
248 parm [edi] [eax] [ebx] \
249 value [eax] \
250 modify exact [eax ebx];
251
252 u8 daa_byte_asm(u32 * flags, u8 d);
253
254 #pragma aux daa_byte_asm = \
255 "push [edi]" \
256 "popf" \
257 "daa" \
258 "pushf" \
259 "pop [edi]" \
260 parm [edi] [al] \
261 value [al] \
262 modify exact [al];
263
264 u8 das_byte_asm(u32 * flags, u8 d);
265
266 #pragma aux das_byte_asm = \
267 "push [edi]" \
268 "popf" \
269 "das" \
270 "pushf" \
271 "pop [edi]" \
272 parm [edi] [al] \
273 value [al] \
274 modify exact [al];
275
276 u8 dec_byte_asm(u32 * flags, u8 d);
277
278 #pragma aux dec_byte_asm = \
279 "push [edi]" \
280 "popf" \
281 "dec al" \
282 "pushf" \
283 "pop [edi]" \
284 parm [edi] [al] \
285 value [al] \
286 modify exact [al];
287
288 u16 dec_word_asm(u32 * flags, u16 d);
289
290 #pragma aux dec_word_asm = \
291 "push [edi]" \
292 "popf" \
293 "dec ax" \
294 "pushf" \
295 "pop [edi]" \
296 parm [edi] [ax] \
297 value [ax] \
298 modify exact [ax];
299
300 u32 dec_long_asm(u32 * flags, u32 d);
301
302 #pragma aux dec_long_asm = \
303 "push [edi]" \
304 "popf" \
305 "dec eax" \
306 "pushf" \
307 "pop [edi]" \
308 parm [edi] [eax] \
309 value [eax] \
310 modify exact [eax];
311
312 u8 inc_byte_asm(u32 * flags, u8 d);
313
314 #pragma aux inc_byte_asm = \
315 "push [edi]" \
316 "popf" \
317 "inc al" \
318 "pushf" \
319 "pop [edi]" \
320 parm [edi] [al] \
321 value [al] \
322 modify exact [al];
323
324 u16 inc_word_asm(u32 * flags, u16 d);
325
326 #pragma aux inc_word_asm = \
327 "push [edi]" \
328 "popf" \
329 "inc ax" \
330 "pushf" \
331 "pop [edi]" \
332 parm [edi] [ax] \
333 value [ax] \
334 modify exact [ax];
335
336 u32 inc_long_asm(u32 * flags, u32 d);
337
338 #pragma aux inc_long_asm = \
339 "push [edi]" \
340 "popf" \
341 "inc eax" \
342 "pushf" \
343 "pop [edi]" \
344 parm [edi] [eax] \
345 value [eax] \
346 modify exact [eax];
347
348 u8 or_byte_asm(u32 * flags, u8 d, u8 s);
349
350 #pragma aux or_byte_asm = \
351 "push [edi]" \
352 "popf" \
353 "or al,bl" \
354 "pushf" \
355 "pop [edi]" \
356 parm [edi] [al] [bl] \
357 value [al] \
358 modify exact [al bl];
359
360 u16 or_word_asm(u32 * flags, u16 d, u16 s);
361
362 #pragma aux or_word_asm = \
363 "push [edi]" \
364 "popf" \
365 "or ax,bx" \
366 "pushf" \
367 "pop [edi]" \
368 parm [edi] [ax] [bx] \
369 value [ax] \
370 modify exact [ax bx];
371
372 u32 or_long_asm(u32 * flags, u32 d, u32 s);
373
374 #pragma aux or_long_asm = \
375 "push [edi]" \
376 "popf" \
377 "or eax,ebx" \
378 "pushf" \
379 "pop [edi]" \
380 parm [edi] [eax] [ebx] \
381 value [eax] \
382 modify exact [eax ebx];
383
384 u8 neg_byte_asm(u32 * flags, u8 d);
385
386 #pragma aux neg_byte_asm = \
387 "push [edi]" \
388 "popf" \
389 "neg al" \
390 "pushf" \
391 "pop [edi]" \
392 parm [edi] [al] \
393 value [al] \
394 modify exact [al];
395
396 u16 neg_word_asm(u32 * flags, u16 d);
397
398 #pragma aux neg_word_asm = \
399 "push [edi]" \
400 "popf" \
401 "neg ax" \
402 "pushf" \
403 "pop [edi]" \
404 parm [edi] [ax] \
405 value [ax] \
406 modify exact [ax];
407
408 u32 neg_long_asm(u32 * flags, u32 d);
409
410 #pragma aux neg_long_asm = \
411 "push [edi]" \
412 "popf" \
413 "neg eax" \
414 "pushf" \
415 "pop [edi]" \
416 parm [edi] [eax] \
417 value [eax] \
418 modify exact [eax];
419
420 u8 not_byte_asm(u32 * flags, u8 d);
421
422 #pragma aux not_byte_asm = \
423 "push [edi]" \
424 "popf" \
425 "not al" \
426 "pushf" \
427 "pop [edi]" \
428 parm [edi] [al] \
429 value [al] \
430 modify exact [al];
431
432 u16 not_word_asm(u32 * flags, u16 d);
433
434 #pragma aux not_word_asm = \
435 "push [edi]" \
436 "popf" \
437 "not ax" \
438 "pushf" \
439 "pop [edi]" \
440 parm [edi] [ax] \
441 value [ax] \
442 modify exact [ax];
443
444 u32 not_long_asm(u32 * flags, u32 d);
445
446 #pragma aux not_long_asm = \
447 "push [edi]" \
448 "popf" \
449 "not eax" \
450 "pushf" \
451 "pop [edi]" \
452 parm [edi] [eax] \
453 value [eax] \
454 modify exact [eax];
455
456 u8 rcl_byte_asm(u32 * flags, u8 d, u8 s);
457
458 #pragma aux rcl_byte_asm = \
459 "push [edi]" \
460 "popf" \
461 "rcl al,cl" \
462 "pushf" \
463 "pop [edi]" \
464 parm [edi] [al] [cl] \
465 value [al] \
466 modify exact [al cl];
467
468 u16 rcl_word_asm(u32 * flags, u16 d, u8 s);
469
470 #pragma aux rcl_word_asm = \
471 "push [edi]" \
472 "popf" \
473 "rcl ax,cl" \
474 "pushf" \
475 "pop [edi]" \
476 parm [edi] [ax] [cl] \
477 value [ax] \
478 modify exact [ax cl];
479
480 u32 rcl_long_asm(u32 * flags, u32 d, u8 s);
481
482 #pragma aux rcl_long_asm = \
483 "push [edi]" \
484 "popf" \
485 "rcl eax,cl" \
486 "pushf" \
487 "pop [edi]" \
488 parm [edi] [eax] [cl] \
489 value [eax] \
490 modify exact [eax cl];
491
492 u8 rcr_byte_asm(u32 * flags, u8 d, u8 s);
493
494 #pragma aux rcr_byte_asm = \
495 "push [edi]" \
496 "popf" \
497 "rcr al,cl" \
498 "pushf" \
499 "pop [edi]" \
500 parm [edi] [al] [cl] \
501 value [al] \
502 modify exact [al cl];
503
504 u16 rcr_word_asm(u32 * flags, u16 d, u8 s);
505
506 #pragma aux rcr_word_asm = \
507 "push [edi]" \
508 "popf" \
509 "rcr ax,cl" \
510 "pushf" \
511 "pop [edi]" \
512 parm [edi] [ax] [cl] \
513 value [ax] \
514 modify exact [ax cl];
515
516 u32 rcr_long_asm(u32 * flags, u32 d, u8 s);
517
518 #pragma aux rcr_long_asm = \
519 "push [edi]" \
520 "popf" \
521 "rcr eax,cl" \
522 "pushf" \
523 "pop [edi]" \
524 parm [edi] [eax] [cl] \
525 value [eax] \
526 modify exact [eax cl];
527
528 u8 rol_byte_asm(u32 * flags, u8 d, u8 s);
529
530 #pragma aux rol_byte_asm = \
531 "push [edi]" \
532 "popf" \
533 "rol al,cl" \
534 "pushf" \
535 "pop [edi]" \
536 parm [edi] [al] [cl] \
537 value [al] \
538 modify exact [al cl];
539
540 u16 rol_word_asm(u32 * flags, u16 d, u8 s);
541
542 #pragma aux rol_word_asm = \
543 "push [edi]" \
544 "popf" \
545 "rol ax,cl" \
546 "pushf" \
547 "pop [edi]" \
548 parm [edi] [ax] [cl] \
549 value [ax] \
550 modify exact [ax cl];
551
552 u32 rol_long_asm(u32 * flags, u32 d, u8 s);
553
554 #pragma aux rol_long_asm = \
555 "push [edi]" \
556 "popf" \
557 "rol eax,cl" \
558 "pushf" \
559 "pop [edi]" \
560 parm [edi] [eax] [cl] \
561 value [eax] \
562 modify exact [eax cl];
563
564 u8 ror_byte_asm(u32 * flags, u8 d, u8 s);
565
566 #pragma aux ror_byte_asm = \
567 "push [edi]" \
568 "popf" \
569 "ror al,cl" \
570 "pushf" \
571 "pop [edi]" \
572 parm [edi] [al] [cl] \
573 value [al] \
574 modify exact [al cl];
575
576 u16 ror_word_asm(u32 * flags, u16 d, u8 s);
577
578 #pragma aux ror_word_asm = \
579 "push [edi]" \
580 "popf" \
581 "ror ax,cl" \
582 "pushf" \
583 "pop [edi]" \
584 parm [edi] [ax] [cl] \
585 value [ax] \
586 modify exact [ax cl];
587
588 u32 ror_long_asm(u32 * flags, u32 d, u8 s);
589
590 #pragma aux ror_long_asm = \
591 "push [edi]" \
592 "popf" \
593 "ror eax,cl" \
594 "pushf" \
595 "pop [edi]" \
596 parm [edi] [eax] [cl] \
597 value [eax] \
598 modify exact [eax cl];
599
600 u8 shl_byte_asm(u32 * flags, u8 d, u8 s);
601
602 #pragma aux shl_byte_asm = \
603 "push [edi]" \
604 "popf" \
605 "shl al,cl" \
606 "pushf" \
607 "pop [edi]" \
608 parm [edi] [al] [cl] \
609 value [al] \
610 modify exact [al cl];
611
612 u16 shl_word_asm(u32 * flags, u16 d, u8 s);
613
614 #pragma aux shl_word_asm = \
615 "push [edi]" \
616 "popf" \
617 "shl ax,cl" \
618 "pushf" \
619 "pop [edi]" \
620 parm [edi] [ax] [cl] \
621 value [ax] \
622 modify exact [ax cl];
623
624 u32 shl_long_asm(u32 * flags, u32 d, u8 s);
625
626 #pragma aux shl_long_asm = \
627 "push [edi]" \
628 "popf" \
629 "shl eax,cl" \
630 "pushf" \
631 "pop [edi]" \
632 parm [edi] [eax] [cl] \
633 value [eax] \
634 modify exact [eax cl];
635
636 u8 shr_byte_asm(u32 * flags, u8 d, u8 s);
637
638 #pragma aux shr_byte_asm = \
639 "push [edi]" \
640 "popf" \
641 "shr al,cl" \
642 "pushf" \
643 "pop [edi]" \
644 parm [edi] [al] [cl] \
645 value [al] \
646 modify exact [al cl];
647
648 u16 shr_word_asm(u32 * flags, u16 d, u8 s);
649
650 #pragma aux shr_word_asm = \
651 "push [edi]" \
652 "popf" \
653 "shr ax,cl" \
654 "pushf" \
655 "pop [edi]" \
656 parm [edi] [ax] [cl] \
657 value [ax] \
658 modify exact [ax cl];
659
660 u32 shr_long_asm(u32 * flags, u32 d, u8 s);
661
662 #pragma aux shr_long_asm = \
663 "push [edi]" \
664 "popf" \
665 "shr eax,cl" \
666 "pushf" \
667 "pop [edi]" \
668 parm [edi] [eax] [cl] \
669 value [eax] \
670 modify exact [eax cl];
671
672 u8 sar_byte_asm(u32 * flags, u8 d, u8 s);
673
674 #pragma aux sar_byte_asm = \
675 "push [edi]" \
676 "popf" \
677 "sar al,cl" \
678 "pushf" \
679 "pop [edi]" \
680 parm [edi] [al] [cl] \
681 value [al] \
682 modify exact [al cl];
683
684 u16 sar_word_asm(u32 * flags, u16 d, u8 s);
685
686 #pragma aux sar_word_asm = \
687 "push [edi]" \
688 "popf" \
689 "sar ax,cl" \
690 "pushf" \
691 "pop [edi]" \
692 parm [edi] [ax] [cl] \
693 value [ax] \
694 modify exact [ax cl];
695
696 u32 sar_long_asm(u32 * flags, u32 d, u8 s);
697
698 #pragma aux sar_long_asm = \
699 "push [edi]" \
700 "popf" \
701 "sar eax,cl" \
702 "pushf" \
703 "pop [edi]" \
704 parm [edi] [eax] [cl] \
705 value [eax] \
706 modify exact [eax cl];
707
708 u16 shld_word_asm(u32 * flags, u16 d, u16 fill, u8 s);
709
710 #pragma aux shld_word_asm = \
711 "push [edi]" \
712 "popf" \
713 "shld ax,dx,cl" \
714 "pushf" \
715 "pop [edi]" \
716 parm [edi] [ax] [dx] [cl] \
717 value [ax] \
718 modify exact [ax dx cl];
719
720 u32 shld_long_asm(u32 * flags, u32 d, u32 fill, u8 s);
721
722 #pragma aux shld_long_asm = \
723 "push [edi]" \
724 "popf" \
725 "shld eax,edx,cl" \
726 "pushf" \
727 "pop [edi]" \
728 parm [edi] [eax] [edx] [cl] \
729 value [eax] \
730 modify exact [eax edx cl];
731
732 u16 shrd_word_asm(u32 * flags, u16 d, u16 fill, u8 s);
733
734 #pragma aux shrd_word_asm = \
735 "push [edi]" \
736 "popf" \
737 "shrd ax,dx,cl" \
738 "pushf" \
739 "pop [edi]" \
740 parm [edi] [ax] [dx] [cl] \
741 value [ax] \
742 modify exact [ax dx cl];
743
744 u32 shrd_long_asm(u32 * flags, u32 d, u32 fill, u8 s);
745
746 #pragma aux shrd_long_asm = \
747 "push [edi]" \
748 "popf" \
749 "shrd eax,edx,cl" \
750 "pushf" \
751 "pop [edi]" \
752 parm [edi] [eax] [edx] [cl] \
753 value [eax] \
754 modify exact [eax edx cl];
755
756 u8 sbb_byte_asm(u32 * flags, u8 d, u8 s);
757
758 #pragma aux sbb_byte_asm = \
759 "push [edi]" \
760 "popf" \
761 "sbb al,bl" \
762 "pushf" \
763 "pop [edi]" \
764 parm [edi] [al] [bl] \
765 value [al] \
766 modify exact [al bl];
767
768 u16 sbb_word_asm(u32 * flags, u16 d, u16 s);
769
770 #pragma aux sbb_word_asm = \
771 "push [edi]" \
772 "popf" \
773 "sbb ax,bx" \
774 "pushf" \
775 "pop [edi]" \
776 parm [edi] [ax] [bx] \
777 value [ax] \
778 modify exact [ax bx];
779
780 u32 sbb_long_asm(u32 * flags, u32 d, u32 s);
781
782 #pragma aux sbb_long_asm = \
783 "push [edi]" \
784 "popf" \
785 "sbb eax,ebx" \
786 "pushf" \
787 "pop [edi]" \
788 parm [edi] [eax] [ebx] \
789 value [eax] \
790 modify exact [eax ebx];
791
792 u8 sub_byte_asm(u32 * flags, u8 d, u8 s);
793
794 #pragma aux sub_byte_asm = \
795 "push [edi]" \
796 "popf" \
797 "sub al,bl" \
798 "pushf" \
799 "pop [edi]" \
800 parm [edi] [al] [bl] \
801 value [al] \
802 modify exact [al bl];
803
804 u16 sub_word_asm(u32 * flags, u16 d, u16 s);
805
806 #pragma aux sub_word_asm = \
807 "push [edi]" \
808 "popf" \
809 "sub ax,bx" \
810 "pushf" \
811 "pop [edi]" \
812 parm [edi] [ax] [bx] \
813 value [ax] \
814 modify exact [ax bx];
815
816 u32 sub_long_asm(u32 * flags, u32 d, u32 s);
817
818 #pragma aux sub_long_asm = \
819 "push [edi]" \
820 "popf" \
821 "sub eax,ebx" \
822 "pushf" \
823 "pop [edi]" \
824 parm [edi] [eax] [ebx] \
825 value [eax] \
826 modify exact [eax ebx];
827
828 void test_byte_asm(u32 * flags, u8 d, u8 s);
829
830 #pragma aux test_byte_asm = \
831 "push [edi]" \
832 "popf" \
833 "test al,bl" \
834 "pushf" \
835 "pop [edi]" \
836 parm [edi] [al] [bl] \
837 modify exact [al bl];
838
839 void test_word_asm(u32 * flags, u16 d, u16 s);
840
841 #pragma aux test_word_asm = \
842 "push [edi]" \
843 "popf" \
844 "test ax,bx" \
845 "pushf" \
846 "pop [edi]" \
847 parm [edi] [ax] [bx] \
848 modify exact [ax bx];
849
850 void test_long_asm(u32 * flags, u32 d, u32 s);
851
852 #pragma aux test_long_asm = \
853 "push [edi]" \
854 "popf" \
855 "test eax,ebx" \
856 "pushf" \
857 "pop [edi]" \
858 parm [edi] [eax] [ebx] \
859 modify exact [eax ebx];
860
861 u8 xor_byte_asm(u32 * flags, u8 d, u8 s);
862
863 #pragma aux xor_byte_asm = \
864 "push [edi]" \
865 "popf" \
866 "xor al,bl" \
867 "pushf" \
868 "pop [edi]" \
869 parm [edi] [al] [bl] \
870 value [al] \
871 modify exact [al bl];
872
873 u16 xor_word_asm(u32 * flags, u16 d, u16 s);
874
875 #pragma aux xor_word_asm = \
876 "push [edi]" \
877 "popf" \
878 "xor ax,bx" \
879 "pushf" \
880 "pop [edi]" \
881 parm [edi] [ax] [bx] \
882 value [ax] \
883 modify exact [ax bx];
884
885 u32 xor_long_asm(u32 * flags, u32 d, u32 s);
886
887 #pragma aux xor_long_asm = \
888 "push [edi]" \
889 "popf" \
890 "xor eax,ebx" \
891 "pushf" \
892 "pop [edi]" \
893 parm [edi] [eax] [ebx] \
894 value [eax] \
895 modify exact [eax ebx];
896
897 void imul_byte_asm(u32 * flags, u16 * ax, u8 d, u8 s);
898
899 #pragma aux imul_byte_asm = \
900 "push [edi]" \
901 "popf" \
902 "imul bl" \
903 "pushf" \
904 "pop [edi]" \
905 "mov [esi],ax" \
906 parm [edi] [esi] [al] [bl] \
907 modify exact [esi ax bl];
908
909 void imul_word_asm(u32 * flags, u16 * ax, u16 * dx, u16 d, u16 s);
910
911 #pragma aux imul_word_asm = \
912 "push [edi]" \
913 "popf" \
914 "imul bx" \
915 "pushf" \
916 "pop [edi]" \
917 "mov [esi],ax" \
918 "mov [ecx],dx" \
919 parm [edi] [esi] [ecx] [ax] [bx]\
920 modify exact [esi edi ax bx dx];
921
922 void imul_long_asm(u32 * flags, u32 * eax, u32 * edx, u32 d, u32 s);
923
924 #pragma aux imul_long_asm = \
925 "push [edi]" \
926 "popf" \
927 "imul ebx" \
928 "pushf" \
929 "pop [edi]" \
930 "mov [esi],eax" \
931 "mov [ecx],edx" \
932 parm [edi] [esi] [ecx] [eax] [ebx] \
933 modify exact [esi edi eax ebx edx];
934
935 void mul_byte_asm(u32 * flags, u16 * ax, u8 d, u8 s);
936
937 #pragma aux mul_byte_asm = \
938 "push [edi]" \
939 "popf" \
940 "mul bl" \
941 "pushf" \
942 "pop [edi]" \
943 "mov [esi],ax" \
944 parm [edi] [esi] [al] [bl] \
945 modify exact [esi ax bl];
946
947 void mul_word_asm(u32 * flags, u16 * ax, u16 * dx, u16 d, u16 s);
948
949 #pragma aux mul_word_asm = \
950 "push [edi]" \
951 "popf" \
952 "mul bx" \
953 "pushf" \
954 "pop [edi]" \
955 "mov [esi],ax" \
956 "mov [ecx],dx" \
957 parm [edi] [esi] [ecx] [ax] [bx]\
958 modify exact [esi edi ax bx dx];
959
960 void mul_long_asm(u32 * flags, u32 * eax, u32 * edx, u32 d, u32 s);
961
962 #pragma aux mul_long_asm = \
963 "push [edi]" \
964 "popf" \
965 "mul ebx" \
966 "pushf" \
967 "pop [edi]" \
968 "mov [esi],eax" \
969 "mov [ecx],edx" \
970 parm [edi] [esi] [ecx] [eax] [ebx] \
971 modify exact [esi edi eax ebx edx];
972
973 void idiv_byte_asm(u32 * flags, u8 * al, u8 * ah, u16 d, u8 s);
974
975 #pragma aux idiv_byte_asm = \
976 "push [edi]" \
977 "popf" \
978 "idiv bl" \
979 "pushf" \
980 "pop [edi]" \
981 "mov [esi],al" \
982 "mov [ecx],ah" \
983 parm [edi] [esi] [ecx] [ax] [bl]\
984 modify exact [esi edi ax bl];
985
986 void idiv_word_asm(u32 * flags, u16 * ax, u16 * dx, u16 dlo, u16 dhi, u16 s);
987
988 #pragma aux idiv_word_asm = \
989 "push [edi]" \
990 "popf" \
991 "idiv bx" \
992 "pushf" \
993 "pop [edi]" \
994 "mov [esi],ax" \
995 "mov [ecx],dx" \
996 parm [edi] [esi] [ecx] [ax] [dx] [bx]\
997 modify exact [esi edi ax dx bx];
998
999 void idiv_long_asm(u32 * flags, u32 * eax, u32 * edx, u32 dlo, u32 dhi, u32 s);
1000
1001 #pragma aux idiv_long_asm = \
1002 "push [edi]" \
1003 "popf" \
1004 "idiv ebx" \
1005 "pushf" \
1006 "pop [edi]" \
1007 "mov [esi],eax" \
1008 "mov [ecx],edx" \
1009 parm [edi] [esi] [ecx] [eax] [edx] [ebx]\
1010 modify exact [esi edi eax edx ebx];
1011
1012 void div_byte_asm(u32 * flags, u8 * al, u8 * ah, u16 d, u8 s);
1013
1014 #pragma aux div_byte_asm = \
1015 "push [edi]" \
1016 "popf" \
1017 "div bl" \
1018 "pushf" \
1019 "pop [edi]" \
1020 "mov [esi],al" \
1021 "mov [ecx],ah" \
1022 parm [edi] [esi] [ecx] [ax] [bl]\
1023 modify exact [esi edi ax bl];
1024
1025 void div_word_asm(u32 * flags, u16 * ax, u16 * dx, u16 dlo, u16 dhi, u16 s);
1026
1027 #pragma aux div_word_asm = \
1028 "push [edi]" \
1029 "popf" \
1030 "div bx" \
1031 "pushf" \
1032 "pop [edi]" \
1033 "mov [esi],ax" \
1034 "mov [ecx],dx" \
1035 parm [edi] [esi] [ecx] [ax] [dx] [bx]\
1036 modify exact [esi edi ax dx bx];
1037
1038 void div_long_asm(u32 * flags, u32 * eax, u32 * edx, u32 dlo, u32 dhi, u32 s);
1039
1040 #pragma aux div_long_asm = \
1041 "push [edi]" \
1042 "popf" \
1043 "div ebx" \
1044 "pushf" \
1045 "pop [edi]" \
1046 "mov [esi],eax" \
1047 "mov [ecx],edx" \
1048 parm [edi] [esi] [ecx] [eax] [edx] [ebx]\
1049 modify exact [esi edi eax edx ebx];
1050
1051 #endif
1052
1053 #endif /* __X86EMU_PRIM_ASM_H */
xorg-server Piment Noir Debian package repository