]>
Commit | Line | Data |
---|---|---|
93afd047 MT |
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 | /* $XFree86$ */ | |
43 | ||
44 | #ifndef __X86EMU_PRIM_ASM_H | |
45 | #define __X86EMU_PRIM_ASM_H | |
46 | ||
47 | #ifdef __WATCOMC__ | |
48 | ||
49 | #ifndef VALIDATE | |
50 | #define __HAVE_INLINE_ASSEMBLER__ | |
51 | #endif | |
52 | ||
53 | u32 get_flags_asm(void); | |
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 | #pragma aux aaa_word_asm = \ | |
62 | "push [edi]" \ | |
63 | "popf" \ | |
64 | "aaa" \ | |
65 | "pushf" \ | |
66 | "pop [edi]" \ | |
67 | parm [edi] [ax] \ | |
68 | value [ax] \ | |
69 | modify exact [ax]; | |
70 | ||
71 | u16 aas_word_asm(u32 *flags,u16 d); | |
72 | #pragma aux aas_word_asm = \ | |
73 | "push [edi]" \ | |
74 | "popf" \ | |
75 | "aas" \ | |
76 | "pushf" \ | |
77 | "pop [edi]" \ | |
78 | parm [edi] [ax] \ | |
79 | value [ax] \ | |
80 | modify exact [ax]; | |
81 | ||
82 | u16 aad_word_asm(u32 *flags,u16 d); | |
83 | #pragma aux aad_word_asm = \ | |
84 | "push [edi]" \ | |
85 | "popf" \ | |
86 | "aad" \ | |
87 | "pushf" \ | |
88 | "pop [edi]" \ | |
89 | parm [edi] [ax] \ | |
90 | value [ax] \ | |
91 | modify exact [ax]; | |
92 | ||
93 | u16 aam_word_asm(u32 *flags,u8 d); | |
94 | #pragma aux aam_word_asm = \ | |
95 | "push [edi]" \ | |
96 | "popf" \ | |
97 | "aam" \ | |
98 | "pushf" \ | |
99 | "pop [edi]" \ | |
100 | parm [edi] [al] \ | |
101 | value [ax] \ | |
102 | modify exact [ax]; | |
103 | ||
104 | u8 adc_byte_asm(u32 *flags,u8 d, u8 s); | |
105 | #pragma aux adc_byte_asm = \ | |
106 | "push [edi]" \ | |
107 | "popf" \ | |
108 | "adc al,bl" \ | |
109 | "pushf" \ | |
110 | "pop [edi]" \ | |
111 | parm [edi] [al] [bl] \ | |
112 | value [al] \ | |
113 | modify exact [al bl]; | |
114 | ||
115 | u16 adc_word_asm(u32 *flags,u16 d, u16 s); | |
116 | #pragma aux adc_word_asm = \ | |
117 | "push [edi]" \ | |
118 | "popf" \ | |
119 | "adc ax,bx" \ | |
120 | "pushf" \ | |
121 | "pop [edi]" \ | |
122 | parm [edi] [ax] [bx] \ | |
123 | value [ax] \ | |
124 | modify exact [ax bx]; | |
125 | ||
126 | u32 adc_long_asm(u32 *flags,u32 d, u32 s); | |
127 | #pragma aux adc_long_asm = \ | |
128 | "push [edi]" \ | |
129 | "popf" \ | |
130 | "adc eax,ebx" \ | |
131 | "pushf" \ | |
132 | "pop [edi]" \ | |
133 | parm [edi] [eax] [ebx] \ | |
134 | value [eax] \ | |
135 | modify exact [eax ebx]; | |
136 | ||
137 | u8 add_byte_asm(u32 *flags,u8 d, u8 s); | |
138 | #pragma aux add_byte_asm = \ | |
139 | "push [edi]" \ | |
140 | "popf" \ | |
141 | "add al,bl" \ | |
142 | "pushf" \ | |
143 | "pop [edi]" \ | |
144 | parm [edi] [al] [bl] \ | |
145 | value [al] \ | |
146 | modify exact [al bl]; | |
147 | ||
148 | u16 add_word_asm(u32 *flags,u16 d, u16 s); | |
149 | #pragma aux add_word_asm = \ | |
150 | "push [edi]" \ | |
151 | "popf" \ | |
152 | "add ax,bx" \ | |
153 | "pushf" \ | |
154 | "pop [edi]" \ | |
155 | parm [edi] [ax] [bx] \ | |
156 | value [ax] \ | |
157 | modify exact [ax bx]; | |
158 | ||
159 | u32 add_long_asm(u32 *flags,u32 d, u32 s); | |
160 | #pragma aux add_long_asm = \ | |
161 | "push [edi]" \ | |
162 | "popf" \ | |
163 | "add eax,ebx" \ | |
164 | "pushf" \ | |
165 | "pop [edi]" \ | |
166 | parm [edi] [eax] [ebx] \ | |
167 | value [eax] \ | |
168 | modify exact [eax ebx]; | |
169 | ||
170 | u8 and_byte_asm(u32 *flags,u8 d, u8 s); | |
171 | #pragma aux and_byte_asm = \ | |
172 | "push [edi]" \ | |
173 | "popf" \ | |
174 | "and al,bl" \ | |
175 | "pushf" \ | |
176 | "pop [edi]" \ | |
177 | parm [edi] [al] [bl] \ | |
178 | value [al] \ | |
179 | modify exact [al bl]; | |
180 | ||
181 | u16 and_word_asm(u32 *flags,u16 d, u16 s); | |
182 | #pragma aux and_word_asm = \ | |
183 | "push [edi]" \ | |
184 | "popf" \ | |
185 | "and ax,bx" \ | |
186 | "pushf" \ | |
187 | "pop [edi]" \ | |
188 | parm [edi] [ax] [bx] \ | |
189 | value [ax] \ | |
190 | modify exact [ax bx]; | |
191 | ||
192 | u32 and_long_asm(u32 *flags,u32 d, u32 s); | |
193 | #pragma aux and_long_asm = \ | |
194 | "push [edi]" \ | |
195 | "popf" \ | |
196 | "and eax,ebx" \ | |
197 | "pushf" \ | |
198 | "pop [edi]" \ | |
199 | parm [edi] [eax] [ebx] \ | |
200 | value [eax] \ | |
201 | modify exact [eax ebx]; | |
202 | ||
203 | u8 cmp_byte_asm(u32 *flags,u8 d, u8 s); | |
204 | #pragma aux cmp_byte_asm = \ | |
205 | "push [edi]" \ | |
206 | "popf" \ | |
207 | "cmp al,bl" \ | |
208 | "pushf" \ | |
209 | "pop [edi]" \ | |
210 | parm [edi] [al] [bl] \ | |
211 | value [al] \ | |
212 | modify exact [al bl]; | |
213 | ||
214 | u16 cmp_word_asm(u32 *flags,u16 d, u16 s); | |
215 | #pragma aux cmp_word_asm = \ | |
216 | "push [edi]" \ | |
217 | "popf" \ | |
218 | "cmp ax,bx" \ | |
219 | "pushf" \ | |
220 | "pop [edi]" \ | |
221 | parm [edi] [ax] [bx] \ | |
222 | value [ax] \ | |
223 | modify exact [ax bx]; | |
224 | ||
225 | u32 cmp_long_asm(u32 *flags,u32 d, u32 s); | |
226 | #pragma aux cmp_long_asm = \ | |
227 | "push [edi]" \ | |
228 | "popf" \ | |
229 | "cmp eax,ebx" \ | |
230 | "pushf" \ | |
231 | "pop [edi]" \ | |
232 | parm [edi] [eax] [ebx] \ | |
233 | value [eax] \ | |
234 | modify exact [eax ebx]; | |
235 | ||
236 | u8 daa_byte_asm(u32 *flags,u8 d); | |
237 | #pragma aux daa_byte_asm = \ | |
238 | "push [edi]" \ | |
239 | "popf" \ | |
240 | "daa" \ | |
241 | "pushf" \ | |
242 | "pop [edi]" \ | |
243 | parm [edi] [al] \ | |
244 | value [al] \ | |
245 | modify exact [al]; | |
246 | ||
247 | u8 das_byte_asm(u32 *flags,u8 d); | |
248 | #pragma aux das_byte_asm = \ | |
249 | "push [edi]" \ | |
250 | "popf" \ | |
251 | "das" \ | |
252 | "pushf" \ | |
253 | "pop [edi]" \ | |
254 | parm [edi] [al] \ | |
255 | value [al] \ | |
256 | modify exact [al]; | |
257 | ||
258 | u8 dec_byte_asm(u32 *flags,u8 d); | |
259 | #pragma aux dec_byte_asm = \ | |
260 | "push [edi]" \ | |
261 | "popf" \ | |
262 | "dec al" \ | |
263 | "pushf" \ | |
264 | "pop [edi]" \ | |
265 | parm [edi] [al] \ | |
266 | value [al] \ | |
267 | modify exact [al]; | |
268 | ||
269 | u16 dec_word_asm(u32 *flags,u16 d); | |
270 | #pragma aux dec_word_asm = \ | |
271 | "push [edi]" \ | |
272 | "popf" \ | |
273 | "dec ax" \ | |
274 | "pushf" \ | |
275 | "pop [edi]" \ | |
276 | parm [edi] [ax] \ | |
277 | value [ax] \ | |
278 | modify exact [ax]; | |
279 | ||
280 | u32 dec_long_asm(u32 *flags,u32 d); | |
281 | #pragma aux dec_long_asm = \ | |
282 | "push [edi]" \ | |
283 | "popf" \ | |
284 | "dec eax" \ | |
285 | "pushf" \ | |
286 | "pop [edi]" \ | |
287 | parm [edi] [eax] \ | |
288 | value [eax] \ | |
289 | modify exact [eax]; | |
290 | ||
291 | u8 inc_byte_asm(u32 *flags,u8 d); | |
292 | #pragma aux inc_byte_asm = \ | |
293 | "push [edi]" \ | |
294 | "popf" \ | |
295 | "inc al" \ | |
296 | "pushf" \ | |
297 | "pop [edi]" \ | |
298 | parm [edi] [al] \ | |
299 | value [al] \ | |
300 | modify exact [al]; | |
301 | ||
302 | u16 inc_word_asm(u32 *flags,u16 d); | |
303 | #pragma aux inc_word_asm = \ | |
304 | "push [edi]" \ | |
305 | "popf" \ | |
306 | "inc ax" \ | |
307 | "pushf" \ | |
308 | "pop [edi]" \ | |
309 | parm [edi] [ax] \ | |
310 | value [ax] \ | |
311 | modify exact [ax]; | |
312 | ||
313 | u32 inc_long_asm(u32 *flags,u32 d); | |
314 | #pragma aux inc_long_asm = \ | |
315 | "push [edi]" \ | |
316 | "popf" \ | |
317 | "inc eax" \ | |
318 | "pushf" \ | |
319 | "pop [edi]" \ | |
320 | parm [edi] [eax] \ | |
321 | value [eax] \ | |
322 | modify exact [eax]; | |
323 | ||
324 | u8 or_byte_asm(u32 *flags,u8 d, u8 s); | |
325 | #pragma aux or_byte_asm = \ | |
326 | "push [edi]" \ | |
327 | "popf" \ | |
328 | "or al,bl" \ | |
329 | "pushf" \ | |
330 | "pop [edi]" \ | |
331 | parm [edi] [al] [bl] \ | |
332 | value [al] \ | |
333 | modify exact [al bl]; | |
334 | ||
335 | u16 or_word_asm(u32 *flags,u16 d, u16 s); | |
336 | #pragma aux or_word_asm = \ | |
337 | "push [edi]" \ | |
338 | "popf" \ | |
339 | "or ax,bx" \ | |
340 | "pushf" \ | |
341 | "pop [edi]" \ | |
342 | parm [edi] [ax] [bx] \ | |
343 | value [ax] \ | |
344 | modify exact [ax bx]; | |
345 | ||
346 | u32 or_long_asm(u32 *flags,u32 d, u32 s); | |
347 | #pragma aux or_long_asm = \ | |
348 | "push [edi]" \ | |
349 | "popf" \ | |
350 | "or eax,ebx" \ | |
351 | "pushf" \ | |
352 | "pop [edi]" \ | |
353 | parm [edi] [eax] [ebx] \ | |
354 | value [eax] \ | |
355 | modify exact [eax ebx]; | |
356 | ||
357 | u8 neg_byte_asm(u32 *flags,u8 d); | |
358 | #pragma aux neg_byte_asm = \ | |
359 | "push [edi]" \ | |
360 | "popf" \ | |
361 | "neg al" \ | |
362 | "pushf" \ | |
363 | "pop [edi]" \ | |
364 | parm [edi] [al] \ | |
365 | value [al] \ | |
366 | modify exact [al]; | |
367 | ||
368 | u16 neg_word_asm(u32 *flags,u16 d); | |
369 | #pragma aux neg_word_asm = \ | |
370 | "push [edi]" \ | |
371 | "popf" \ | |
372 | "neg ax" \ | |
373 | "pushf" \ | |
374 | "pop [edi]" \ | |
375 | parm [edi] [ax] \ | |
376 | value [ax] \ | |
377 | modify exact [ax]; | |
378 | ||
379 | u32 neg_long_asm(u32 *flags,u32 d); | |
380 | #pragma aux neg_long_asm = \ | |
381 | "push [edi]" \ | |
382 | "popf" \ | |
383 | "neg eax" \ | |
384 | "pushf" \ | |
385 | "pop [edi]" \ | |
386 | parm [edi] [eax] \ | |
387 | value [eax] \ | |
388 | modify exact [eax]; | |
389 | ||
390 | u8 not_byte_asm(u32 *flags,u8 d); | |
391 | #pragma aux not_byte_asm = \ | |
392 | "push [edi]" \ | |
393 | "popf" \ | |
394 | "not al" \ | |
395 | "pushf" \ | |
396 | "pop [edi]" \ | |
397 | parm [edi] [al] \ | |
398 | value [al] \ | |
399 | modify exact [al]; | |
400 | ||
401 | u16 not_word_asm(u32 *flags,u16 d); | |
402 | #pragma aux not_word_asm = \ | |
403 | "push [edi]" \ | |
404 | "popf" \ | |
405 | "not ax" \ | |
406 | "pushf" \ | |
407 | "pop [edi]" \ | |
408 | parm [edi] [ax] \ | |
409 | value [ax] \ | |
410 | modify exact [ax]; | |
411 | ||
412 | u32 not_long_asm(u32 *flags,u32 d); | |
413 | #pragma aux not_long_asm = \ | |
414 | "push [edi]" \ | |
415 | "popf" \ | |
416 | "not eax" \ | |
417 | "pushf" \ | |
418 | "pop [edi]" \ | |
419 | parm [edi] [eax] \ | |
420 | value [eax] \ | |
421 | modify exact [eax]; | |
422 | ||
423 | u8 rcl_byte_asm(u32 *flags,u8 d, u8 s); | |
424 | #pragma aux rcl_byte_asm = \ | |
425 | "push [edi]" \ | |
426 | "popf" \ | |
427 | "rcl al,cl" \ | |
428 | "pushf" \ | |
429 | "pop [edi]" \ | |
430 | parm [edi] [al] [cl] \ | |
431 | value [al] \ | |
432 | modify exact [al cl]; | |
433 | ||
434 | u16 rcl_word_asm(u32 *flags,u16 d, u8 s); | |
435 | #pragma aux rcl_word_asm = \ | |
436 | "push [edi]" \ | |
437 | "popf" \ | |
438 | "rcl ax,cl" \ | |
439 | "pushf" \ | |
440 | "pop [edi]" \ | |
441 | parm [edi] [ax] [cl] \ | |
442 | value [ax] \ | |
443 | modify exact [ax cl]; | |
444 | ||
445 | u32 rcl_long_asm(u32 *flags,u32 d, u8 s); | |
446 | #pragma aux rcl_long_asm = \ | |
447 | "push [edi]" \ | |
448 | "popf" \ | |
449 | "rcl eax,cl" \ | |
450 | "pushf" \ | |
451 | "pop [edi]" \ | |
452 | parm [edi] [eax] [cl] \ | |
453 | value [eax] \ | |
454 | modify exact [eax cl]; | |
455 | ||
456 | u8 rcr_byte_asm(u32 *flags,u8 d, u8 s); | |
457 | #pragma aux rcr_byte_asm = \ | |
458 | "push [edi]" \ | |
459 | "popf" \ | |
460 | "rcr al,cl" \ | |
461 | "pushf" \ | |
462 | "pop [edi]" \ | |
463 | parm [edi] [al] [cl] \ | |
464 | value [al] \ | |
465 | modify exact [al cl]; | |
466 | ||
467 | u16 rcr_word_asm(u32 *flags,u16 d, u8 s); | |
468 | #pragma aux rcr_word_asm = \ | |
469 | "push [edi]" \ | |
470 | "popf" \ | |
471 | "rcr ax,cl" \ | |
472 | "pushf" \ | |
473 | "pop [edi]" \ | |
474 | parm [edi] [ax] [cl] \ | |
475 | value [ax] \ | |
476 | modify exact [ax cl]; | |
477 | ||
478 | u32 rcr_long_asm(u32 *flags,u32 d, u8 s); | |
479 | #pragma aux rcr_long_asm = \ | |
480 | "push [edi]" \ | |
481 | "popf" \ | |
482 | "rcr eax,cl" \ | |
483 | "pushf" \ | |
484 | "pop [edi]" \ | |
485 | parm [edi] [eax] [cl] \ | |
486 | value [eax] \ | |
487 | modify exact [eax cl]; | |
488 | ||
489 | u8 rol_byte_asm(u32 *flags,u8 d, u8 s); | |
490 | #pragma aux rol_byte_asm = \ | |
491 | "push [edi]" \ | |
492 | "popf" \ | |
493 | "rol al,cl" \ | |
494 | "pushf" \ | |
495 | "pop [edi]" \ | |
496 | parm [edi] [al] [cl] \ | |
497 | value [al] \ | |
498 | modify exact [al cl]; | |
499 | ||
500 | u16 rol_word_asm(u32 *flags,u16 d, u8 s); | |
501 | #pragma aux rol_word_asm = \ | |
502 | "push [edi]" \ | |
503 | "popf" \ | |
504 | "rol ax,cl" \ | |
505 | "pushf" \ | |
506 | "pop [edi]" \ | |
507 | parm [edi] [ax] [cl] \ | |
508 | value [ax] \ | |
509 | modify exact [ax cl]; | |
510 | ||
511 | u32 rol_long_asm(u32 *flags,u32 d, u8 s); | |
512 | #pragma aux rol_long_asm = \ | |
513 | "push [edi]" \ | |
514 | "popf" \ | |
515 | "rol eax,cl" \ | |
516 | "pushf" \ | |
517 | "pop [edi]" \ | |
518 | parm [edi] [eax] [cl] \ | |
519 | value [eax] \ | |
520 | modify exact [eax cl]; | |
521 | ||
522 | u8 ror_byte_asm(u32 *flags,u8 d, u8 s); | |
523 | #pragma aux ror_byte_asm = \ | |
524 | "push [edi]" \ | |
525 | "popf" \ | |
526 | "ror al,cl" \ | |
527 | "pushf" \ | |
528 | "pop [edi]" \ | |
529 | parm [edi] [al] [cl] \ | |
530 | value [al] \ | |
531 | modify exact [al cl]; | |
532 | ||
533 | u16 ror_word_asm(u32 *flags,u16 d, u8 s); | |
534 | #pragma aux ror_word_asm = \ | |
535 | "push [edi]" \ | |
536 | "popf" \ | |
537 | "ror ax,cl" \ | |
538 | "pushf" \ | |
539 | "pop [edi]" \ | |
540 | parm [edi] [ax] [cl] \ | |
541 | value [ax] \ | |
542 | modify exact [ax cl]; | |
543 | ||
544 | u32 ror_long_asm(u32 *flags,u32 d, u8 s); | |
545 | #pragma aux ror_long_asm = \ | |
546 | "push [edi]" \ | |
547 | "popf" \ | |
548 | "ror eax,cl" \ | |
549 | "pushf" \ | |
550 | "pop [edi]" \ | |
551 | parm [edi] [eax] [cl] \ | |
552 | value [eax] \ | |
553 | modify exact [eax cl]; | |
554 | ||
555 | u8 shl_byte_asm(u32 *flags,u8 d, u8 s); | |
556 | #pragma aux shl_byte_asm = \ | |
557 | "push [edi]" \ | |
558 | "popf" \ | |
559 | "shl al,cl" \ | |
560 | "pushf" \ | |
561 | "pop [edi]" \ | |
562 | parm [edi] [al] [cl] \ | |
563 | value [al] \ | |
564 | modify exact [al cl]; | |
565 | ||
566 | u16 shl_word_asm(u32 *flags,u16 d, u8 s); | |
567 | #pragma aux shl_word_asm = \ | |
568 | "push [edi]" \ | |
569 | "popf" \ | |
570 | "shl ax,cl" \ | |
571 | "pushf" \ | |
572 | "pop [edi]" \ | |
573 | parm [edi] [ax] [cl] \ | |
574 | value [ax] \ | |
575 | modify exact [ax cl]; | |
576 | ||
577 | u32 shl_long_asm(u32 *flags,u32 d, u8 s); | |
578 | #pragma aux shl_long_asm = \ | |
579 | "push [edi]" \ | |
580 | "popf" \ | |
581 | "shl eax,cl" \ | |
582 | "pushf" \ | |
583 | "pop [edi]" \ | |
584 | parm [edi] [eax] [cl] \ | |
585 | value [eax] \ | |
586 | modify exact [eax cl]; | |
587 | ||
588 | u8 shr_byte_asm(u32 *flags,u8 d, u8 s); | |
589 | #pragma aux shr_byte_asm = \ | |
590 | "push [edi]" \ | |
591 | "popf" \ | |
592 | "shr al,cl" \ | |
593 | "pushf" \ | |
594 | "pop [edi]" \ | |
595 | parm [edi] [al] [cl] \ | |
596 | value [al] \ | |
597 | modify exact [al cl]; | |
598 | ||
599 | u16 shr_word_asm(u32 *flags,u16 d, u8 s); | |
600 | #pragma aux shr_word_asm = \ | |
601 | "push [edi]" \ | |
602 | "popf" \ | |
603 | "shr ax,cl" \ | |
604 | "pushf" \ | |
605 | "pop [edi]" \ | |
606 | parm [edi] [ax] [cl] \ | |
607 | value [ax] \ | |
608 | modify exact [ax cl]; | |
609 | ||
610 | u32 shr_long_asm(u32 *flags,u32 d, u8 s); | |
611 | #pragma aux shr_long_asm = \ | |
612 | "push [edi]" \ | |
613 | "popf" \ | |
614 | "shr eax,cl" \ | |
615 | "pushf" \ | |
616 | "pop [edi]" \ | |
617 | parm [edi] [eax] [cl] \ | |
618 | value [eax] \ | |
619 | modify exact [eax cl]; | |
620 | ||
621 | u8 sar_byte_asm(u32 *flags,u8 d, u8 s); | |
622 | #pragma aux sar_byte_asm = \ | |
623 | "push [edi]" \ | |
624 | "popf" \ | |
625 | "sar al,cl" \ | |
626 | "pushf" \ | |
627 | "pop [edi]" \ | |
628 | parm [edi] [al] [cl] \ | |
629 | value [al] \ | |
630 | modify exact [al cl]; | |
631 | ||
632 | u16 sar_word_asm(u32 *flags,u16 d, u8 s); | |
633 | #pragma aux sar_word_asm = \ | |
634 | "push [edi]" \ | |
635 | "popf" \ | |
636 | "sar ax,cl" \ | |
637 | "pushf" \ | |
638 | "pop [edi]" \ | |
639 | parm [edi] [ax] [cl] \ | |
640 | value [ax] \ | |
641 | modify exact [ax cl]; | |
642 | ||
643 | u32 sar_long_asm(u32 *flags,u32 d, u8 s); | |
644 | #pragma aux sar_long_asm = \ | |
645 | "push [edi]" \ | |
646 | "popf" \ | |
647 | "sar eax,cl" \ | |
648 | "pushf" \ | |
649 | "pop [edi]" \ | |
650 | parm [edi] [eax] [cl] \ | |
651 | value [eax] \ | |
652 | modify exact [eax cl]; | |
653 | ||
654 | u16 shld_word_asm(u32 *flags,u16 d, u16 fill, u8 s); | |
655 | #pragma aux shld_word_asm = \ | |
656 | "push [edi]" \ | |
657 | "popf" \ | |
658 | "shld ax,dx,cl" \ | |
659 | "pushf" \ | |
660 | "pop [edi]" \ | |
661 | parm [edi] [ax] [dx] [cl] \ | |
662 | value [ax] \ | |
663 | modify exact [ax dx cl]; | |
664 | ||
665 | u32 shld_long_asm(u32 *flags,u32 d, u32 fill, u8 s); | |
666 | #pragma aux shld_long_asm = \ | |
667 | "push [edi]" \ | |
668 | "popf" \ | |
669 | "shld eax,edx,cl" \ | |
670 | "pushf" \ | |
671 | "pop [edi]" \ | |
672 | parm [edi] [eax] [edx] [cl] \ | |
673 | value [eax] \ | |
674 | modify exact [eax edx cl]; | |
675 | ||
676 | u16 shrd_word_asm(u32 *flags,u16 d, u16 fill, u8 s); | |
677 | #pragma aux shrd_word_asm = \ | |
678 | "push [edi]" \ | |
679 | "popf" \ | |
680 | "shrd ax,dx,cl" \ | |
681 | "pushf" \ | |
682 | "pop [edi]" \ | |
683 | parm [edi] [ax] [dx] [cl] \ | |
684 | value [ax] \ | |
685 | modify exact [ax dx cl]; | |
686 | ||
687 | u32 shrd_long_asm(u32 *flags,u32 d, u32 fill, u8 s); | |
688 | #pragma aux shrd_long_asm = \ | |
689 | "push [edi]" \ | |
690 | "popf" \ | |
691 | "shrd eax,edx,cl" \ | |
692 | "pushf" \ | |
693 | "pop [edi]" \ | |
694 | parm [edi] [eax] [edx] [cl] \ | |
695 | value [eax] \ | |
696 | modify exact [eax edx cl]; | |
697 | ||
698 | u8 sbb_byte_asm(u32 *flags,u8 d, u8 s); | |
699 | #pragma aux sbb_byte_asm = \ | |
700 | "push [edi]" \ | |
701 | "popf" \ | |
702 | "sbb al,bl" \ | |
703 | "pushf" \ | |
704 | "pop [edi]" \ | |
705 | parm [edi] [al] [bl] \ | |
706 | value [al] \ | |
707 | modify exact [al bl]; | |
708 | ||
709 | u16 sbb_word_asm(u32 *flags,u16 d, u16 s); | |
710 | #pragma aux sbb_word_asm = \ | |
711 | "push [edi]" \ | |
712 | "popf" \ | |
713 | "sbb ax,bx" \ | |
714 | "pushf" \ | |
715 | "pop [edi]" \ | |
716 | parm [edi] [ax] [bx] \ | |
717 | value [ax] \ | |
718 | modify exact [ax bx]; | |
719 | ||
720 | u32 sbb_long_asm(u32 *flags,u32 d, u32 s); | |
721 | #pragma aux sbb_long_asm = \ | |
722 | "push [edi]" \ | |
723 | "popf" \ | |
724 | "sbb eax,ebx" \ | |
725 | "pushf" \ | |
726 | "pop [edi]" \ | |
727 | parm [edi] [eax] [ebx] \ | |
728 | value [eax] \ | |
729 | modify exact [eax ebx]; | |
730 | ||
731 | u8 sub_byte_asm(u32 *flags,u8 d, u8 s); | |
732 | #pragma aux sub_byte_asm = \ | |
733 | "push [edi]" \ | |
734 | "popf" \ | |
735 | "sub al,bl" \ | |
736 | "pushf" \ | |
737 | "pop [edi]" \ | |
738 | parm [edi] [al] [bl] \ | |
739 | value [al] \ | |
740 | modify exact [al bl]; | |
741 | ||
742 | u16 sub_word_asm(u32 *flags,u16 d, u16 s); | |
743 | #pragma aux sub_word_asm = \ | |
744 | "push [edi]" \ | |
745 | "popf" \ | |
746 | "sub ax,bx" \ | |
747 | "pushf" \ | |
748 | "pop [edi]" \ | |
749 | parm [edi] [ax] [bx] \ | |
750 | value [ax] \ | |
751 | modify exact [ax bx]; | |
752 | ||
753 | u32 sub_long_asm(u32 *flags,u32 d, u32 s); | |
754 | #pragma aux sub_long_asm = \ | |
755 | "push [edi]" \ | |
756 | "popf" \ | |
757 | "sub eax,ebx" \ | |
758 | "pushf" \ | |
759 | "pop [edi]" \ | |
760 | parm [edi] [eax] [ebx] \ | |
761 | value [eax] \ | |
762 | modify exact [eax ebx]; | |
763 | ||
764 | void test_byte_asm(u32 *flags,u8 d, u8 s); | |
765 | #pragma aux test_byte_asm = \ | |
766 | "push [edi]" \ | |
767 | "popf" \ | |
768 | "test al,bl" \ | |
769 | "pushf" \ | |
770 | "pop [edi]" \ | |
771 | parm [edi] [al] [bl] \ | |
772 | modify exact [al bl]; | |
773 | ||
774 | void test_word_asm(u32 *flags,u16 d, u16 s); | |
775 | #pragma aux test_word_asm = \ | |
776 | "push [edi]" \ | |
777 | "popf" \ | |
778 | "test ax,bx" \ | |
779 | "pushf" \ | |
780 | "pop [edi]" \ | |
781 | parm [edi] [ax] [bx] \ | |
782 | modify exact [ax bx]; | |
783 | ||
784 | void test_long_asm(u32 *flags,u32 d, u32 s); | |
785 | #pragma aux test_long_asm = \ | |
786 | "push [edi]" \ | |
787 | "popf" \ | |
788 | "test eax,ebx" \ | |
789 | "pushf" \ | |
790 | "pop [edi]" \ | |
791 | parm [edi] [eax] [ebx] \ | |
792 | modify exact [eax ebx]; | |
793 | ||
794 | u8 xor_byte_asm(u32 *flags,u8 d, u8 s); | |
795 | #pragma aux xor_byte_asm = \ | |
796 | "push [edi]" \ | |
797 | "popf" \ | |
798 | "xor al,bl" \ | |
799 | "pushf" \ | |
800 | "pop [edi]" \ | |
801 | parm [edi] [al] [bl] \ | |
802 | value [al] \ | |
803 | modify exact [al bl]; | |
804 | ||
805 | u16 xor_word_asm(u32 *flags,u16 d, u16 s); | |
806 | #pragma aux xor_word_asm = \ | |
807 | "push [edi]" \ | |
808 | "popf" \ | |
809 | "xor ax,bx" \ | |
810 | "pushf" \ | |
811 | "pop [edi]" \ | |
812 | parm [edi] [ax] [bx] \ | |
813 | value [ax] \ | |
814 | modify exact [ax bx]; | |
815 | ||
816 | u32 xor_long_asm(u32 *flags,u32 d, u32 s); | |
817 | #pragma aux xor_long_asm = \ | |
818 | "push [edi]" \ | |
819 | "popf" \ | |
820 | "xor eax,ebx" \ | |
821 | "pushf" \ | |
822 | "pop [edi]" \ | |
823 | parm [edi] [eax] [ebx] \ | |
824 | value [eax] \ | |
825 | modify exact [eax ebx]; | |
826 | ||
827 | void imul_byte_asm(u32 *flags,u16 *ax,u8 d,u8 s); | |
828 | #pragma aux imul_byte_asm = \ | |
829 | "push [edi]" \ | |
830 | "popf" \ | |
831 | "imul bl" \ | |
832 | "pushf" \ | |
833 | "pop [edi]" \ | |
834 | "mov [esi],ax" \ | |
835 | parm [edi] [esi] [al] [bl] \ | |
836 | modify exact [esi ax bl]; | |
837 | ||
838 | void imul_word_asm(u32 *flags,u16 *ax,u16 *dx,u16 d,u16 s); | |
839 | #pragma aux imul_word_asm = \ | |
840 | "push [edi]" \ | |
841 | "popf" \ | |
842 | "imul bx" \ | |
843 | "pushf" \ | |
844 | "pop [edi]" \ | |
845 | "mov [esi],ax" \ | |
846 | "mov [ecx],dx" \ | |
847 | parm [edi] [esi] [ecx] [ax] [bx]\ | |
848 | modify exact [esi edi ax bx dx]; | |
849 | ||
850 | void imul_long_asm(u32 *flags,u32 *eax,u32 *edx,u32 d,u32 s); | |
851 | #pragma aux imul_long_asm = \ | |
852 | "push [edi]" \ | |
853 | "popf" \ | |
854 | "imul ebx" \ | |
855 | "pushf" \ | |
856 | "pop [edi]" \ | |
857 | "mov [esi],eax" \ | |
858 | "mov [ecx],edx" \ | |
859 | parm [edi] [esi] [ecx] [eax] [ebx] \ | |
860 | modify exact [esi edi eax ebx edx]; | |
861 | ||
862 | void mul_byte_asm(u32 *flags,u16 *ax,u8 d,u8 s); | |
863 | #pragma aux mul_byte_asm = \ | |
864 | "push [edi]" \ | |
865 | "popf" \ | |
866 | "mul bl" \ | |
867 | "pushf" \ | |
868 | "pop [edi]" \ | |
869 | "mov [esi],ax" \ | |
870 | parm [edi] [esi] [al] [bl] \ | |
871 | modify exact [esi ax bl]; | |
872 | ||
873 | void mul_word_asm(u32 *flags,u16 *ax,u16 *dx,u16 d,u16 s); | |
874 | #pragma aux mul_word_asm = \ | |
875 | "push [edi]" \ | |
876 | "popf" \ | |
877 | "mul bx" \ | |
878 | "pushf" \ | |
879 | "pop [edi]" \ | |
880 | "mov [esi],ax" \ | |
881 | "mov [ecx],dx" \ | |
882 | parm [edi] [esi] [ecx] [ax] [bx]\ | |
883 | modify exact [esi edi ax bx dx]; | |
884 | ||
885 | void mul_long_asm(u32 *flags,u32 *eax,u32 *edx,u32 d,u32 s); | |
886 | #pragma aux mul_long_asm = \ | |
887 | "push [edi]" \ | |
888 | "popf" \ | |
889 | "mul ebx" \ | |
890 | "pushf" \ | |
891 | "pop [edi]" \ | |
892 | "mov [esi],eax" \ | |
893 | "mov [ecx],edx" \ | |
894 | parm [edi] [esi] [ecx] [eax] [ebx] \ | |
895 | modify exact [esi edi eax ebx edx]; | |
896 | ||
897 | void idiv_byte_asm(u32 *flags,u8 *al,u8 *ah,u16 d,u8 s); | |
898 | #pragma aux idiv_byte_asm = \ | |
899 | "push [edi]" \ | |
900 | "popf" \ | |
901 | "idiv bl" \ | |
902 | "pushf" \ | |
903 | "pop [edi]" \ | |
904 | "mov [esi],al" \ | |
905 | "mov [ecx],ah" \ | |
906 | parm [edi] [esi] [ecx] [ax] [bl]\ | |
907 | modify exact [esi edi ax bl]; | |
908 | ||
909 | void idiv_word_asm(u32 *flags,u16 *ax,u16 *dx,u16 dlo,u16 dhi,u16 s); | |
910 | #pragma aux idiv_word_asm = \ | |
911 | "push [edi]" \ | |
912 | "popf" \ | |
913 | "idiv bx" \ | |
914 | "pushf" \ | |
915 | "pop [edi]" \ | |
916 | "mov [esi],ax" \ | |
917 | "mov [ecx],dx" \ | |
918 | parm [edi] [esi] [ecx] [ax] [dx] [bx]\ | |
919 | modify exact [esi edi ax dx bx]; | |
920 | ||
921 | void idiv_long_asm(u32 *flags,u32 *eax,u32 *edx,u32 dlo,u32 dhi,u32 s); | |
922 | #pragma aux idiv_long_asm = \ | |
923 | "push [edi]" \ | |
924 | "popf" \ | |
925 | "idiv ebx" \ | |
926 | "pushf" \ | |
927 | "pop [edi]" \ | |
928 | "mov [esi],eax" \ | |
929 | "mov [ecx],edx" \ | |
930 | parm [edi] [esi] [ecx] [eax] [edx] [ebx]\ | |
931 | modify exact [esi edi eax edx ebx]; | |
932 | ||
933 | void div_byte_asm(u32 *flags,u8 *al,u8 *ah,u16 d,u8 s); | |
934 | #pragma aux div_byte_asm = \ | |
935 | "push [edi]" \ | |
936 | "popf" \ | |
937 | "div bl" \ | |
938 | "pushf" \ | |
939 | "pop [edi]" \ | |
940 | "mov [esi],al" \ | |
941 | "mov [ecx],ah" \ | |
942 | parm [edi] [esi] [ecx] [ax] [bl]\ | |
943 | modify exact [esi edi ax bl]; | |
944 | ||
945 | void div_word_asm(u32 *flags,u16 *ax,u16 *dx,u16 dlo,u16 dhi,u16 s); | |
946 | #pragma aux div_word_asm = \ | |
947 | "push [edi]" \ | |
948 | "popf" \ | |
949 | "div bx" \ | |
950 | "pushf" \ | |
951 | "pop [edi]" \ | |
952 | "mov [esi],ax" \ | |
953 | "mov [ecx],dx" \ | |
954 | parm [edi] [esi] [ecx] [ax] [dx] [bx]\ | |
955 | modify exact [esi edi ax dx bx]; | |
956 | ||
957 | void div_long_asm(u32 *flags,u32 *eax,u32 *edx,u32 dlo,u32 dhi,u32 s); | |
958 | #pragma aux div_long_asm = \ | |
959 | "push [edi]" \ | |
960 | "popf" \ | |
961 | "div ebx" \ | |
962 | "pushf" \ | |
963 | "pop [edi]" \ | |
964 | "mov [esi],eax" \ | |
965 | "mov [ecx],edx" \ | |
966 | parm [edi] [esi] [ecx] [eax] [edx] [ebx]\ | |
967 | modify exact [esi edi eax edx ebx]; | |
968 | ||
969 | #endif | |
970 | ||
971 | #endif /* __X86EMU_PRIM_ASM_H */ |