board/MAI/bios_emulator/scitech/src/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 #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 */