← Back to branch summary

~ubuntu-branches/ubuntu/karmic/virtualbox-ose/karmic-updates

« back to all changes in this revision

Viewing changes to src/VBox/Additions/x11/x11include/xorg-server-1.6.0/prim_asm.h

  • Committer: Bazaar Package Importer
  • Author(s): Felix Geyer
  • Date: 2009-09-14 18:25:07 UTC
  • mfrom: (0.4.1 squeeze)
  • Revision ID: james.westby@ubuntu.com-20090914182507-c98g07mq16hjmn6d
Tags: 3.0.6-dfsg-1ubuntu1
https://launchpad.net/bugs/429697
https://launchpad.net/bugs/267097
https://launchpad.net/bugs/288590
https://launchpad.net/bugs/379878
* Merge from debian unstable (LP: #429697), remaining changes:
  - Enable DKMS support on virtualbox host and guest modules (LP: #267097)
    - Drop virtualbox-ose{-guest,}-modules-* package templates
    - Recommend *-source instead of *-modules packages
    - Replace error messages related to missing/mismatched
      kernel module accordingly
  - Autoload kernel module
    - LOAD_VBOXDRV_MODULE=1 in virtualbox-ose.default
  - Disable update action
    - patches/u01-disable-update-action.dpatch
  - Virtualbox should go in Accessories, not in System tools (LP: #288590)
    - virtualbox-ose-qt.files/virtualbox-ose.desktop
  - Add apport hook
    - virtualbox-ose.files/source_virtualbox-ose.py
    - virtualbox-ose.install
  - Add launchpad integration
    - control
    - lpi-bug.xpm
    - patches/u02-lp-integration.dpatch
  - virtualbox, virtualbox-* (names of the upstream proprietary packages)
    conflict with virtualbox-ose (LP: #379878)
* Make debug package depend on normal or guest utils package
* Drop patches/22-pulseaudio-stubs.dpatch (applied upstream)
* Rename Ubuntu specific patches to uXX-*.dpatch
* Fix lintian warnings in maintainer scripts

Show diffs side-by-side

added added

removed removed

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