Adding upstream version 7.0.14-dfsg.upstream/7.0.14-dfsg

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 983 insertions, 0 deletions

diff --git a/include/iprt/asm-watcom-x86-16.h b/include/iprt/asm-watcom-x86-16.h
new file mode 100644
index 00000000..998fdac6
--- /dev/null
+++ b/include/iprt/asm-watcom-x86-16.h
@@ -0,0 +1,983 @@
+/** @file
+ * IPRT - Assembly Functions, x86 16-bit Watcom C/C++ pragma aux.
+ */
+
+/*
+ * Copyright (C) 2006-2023 Oracle and/or its affiliates.
+ *
+ * This file is part of VirtualBox base platform packages, as
+ * available from https://www.virtualbox.org.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation, in version 3 of the
+ * License.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see <https://www.gnu.org/licenses>.
+ *
+ * The contents of this file may alternatively be used under the terms
+ * of the Common Development and Distribution License Version 1.0
+ * (CDDL), a copy of it is provided in the "COPYING.CDDL" file included
+ * in the VirtualBox distribution, in which case the provisions of the
+ * CDDL are applicable instead of those of the GPL.
+ *
+ * You may elect to license modified versions of this file under the
+ * terms and conditions of either the GPL or the CDDL or both.
+ *
+ * SPDX-License-Identifier: GPL-3.0-only OR CDDL-1.0
+ */
+
+#ifndef IPRT_INCLUDED_asm_watcom_x86_16_h
+#define IPRT_INCLUDED_asm_watcom_x86_16_h
+/* no pragma once */
+
+#ifndef IPRT_INCLUDED_asm_h
+# error "Don't include this header directly."
+#endif
+
+/*
+ * Turns out we cannot use 'ds' for segment stuff here because the compiler
+ * seems to insists on loading the DGROUP segment into 'ds' before calling
+ * stuff when using -ecc.  Using 'es' instead as this seems to work fine.
+ *
+ * Note! The #undef that preceds the #pragma aux statements is for undoing
+ *       the mangling, because the symbol in #pragma aux [symbol] statements
+ *       doesn't get subjected to preprocessing.  This is also why we include
+ *       the watcom header at both the top and the bottom of asm.h file.
+ */
+
+#undef       ASMCompilerBarrier
+#ifdef IPRT_ASM_WATCOM_X86_16_WITH_PRAGMAS
+# if 0 /* overkill version. */
+#  pragma aux ASMCompilerBarrier = \
+    "nop" \
+    parm [] \
+    modify exact [ax bx cx dx es ds];
+# else
+#  pragma aux ASMCompilerBarrier = \
+    "" \
+    parm [] \
+    modify exact [];
+# endif
+#endif
+
+#undef      ASMNopPause
+#ifdef IPRT_ASM_WATCOM_X86_16_WITH_PRAGMAS
+#pragma aux ASMNopPause = \
+    ".686p" \
+    ".xmm2" \
+    "pause" \
+    parm [] nomemory \
+    modify exact [] nomemory;
+#endif
+
+#undef      ASMAtomicXchgU8
+#ifdef IPRT_ASM_WATCOM_X86_16_WITH_PRAGMAS
+#pragma aux ASMAtomicXchgU8 = \
+    "xchg es:[bx], al" \
+    parm [es bx] [al] \
+    value [al] \
+    modify exact [al];
+#endif
+
+#undef      ASMAtomicXchgU16
+#ifdef IPRT_ASM_WATCOM_X86_16_WITH_PRAGMAS
+#pragma aux ASMAtomicXchgU16 = \
+    "xchg es:[bx], ax" \
+    parm [es bx] [ax] \
+    value [ax] \
+    modify exact [ax];
+#endif
+
+#undef      ASMAtomicXchgU32
+#ifdef IPRT_ASM_WATCOM_X86_16_WITH_PRAGMAS
+#pragma aux ASMAtomicXchgU32 = \
+    ".386" \
+    "shl  ecx, 16" \
+    "mov  cx, ax" \
+    "xchg es:[bx], ecx" \
+    "mov  eax, ecx" \
+    "shr  ecx, 16" \
+    parm [es bx] [ax cx] \
+    value [ax cx] \
+    modify exact [ax cx];
+#endif
+
+#undef      ASMAtomicXchgU64
+#ifdef IPRT_ASM_WATCOM_X86_16_WITH_PRAGMAS
+#pragma aux ASMAtomicXchgU64 = \
+    ".586" \
+    "shl eax, 16" \
+    "mov ax, bx" /* eax = high dword */ \
+    "shl ecx, 16" \
+    "mov cx, dx" /* ecx = low dword */ \
+    "mov ebx, ecx" /* ebx = low */ \
+    "mov ecx, eax" /* ecx = high */ \
+    "try_again:" \
+    "lock cmpxchg8b es:[si]" \
+    "jnz try_again" \
+    "xchg eax, edx" \
+    "mov  ebx, eax" \
+    "shr  eax, 16" \
+    "mov  ecx, edx" \
+    "shr  ecx, 16" \
+    parm [es si] [dx cx bx ax] \
+    value [dx cx bx ax] \
+    modify exact [dx cx bx ax];
+#endif
+
+#undef      ASMAtomicCmpXchgU8
+#ifdef IPRT_ASM_WATCOM_X86_16_WITH_PRAGMAS
+#pragma aux ASMAtomicCmpXchgU8 = \
+    ".486" \
+    "lock cmpxchg es:[bx], cl" \
+    "setz al" \
+    parm [es bx] [cl] [al] \
+    value [al] \
+    modify exact [al];
+#endif
+
+#undef      ASMAtomicCmpXchgU16
+#ifdef IPRT_ASM_WATCOM_X86_16_WITH_PRAGMAS
+#pragma aux ASMAtomicCmpXchgU16 = \
+    ".486" \
+    "lock cmpxchg es:[bx], cx" \
+    "setz al" \
+    parm [es bx] [cx] [ax] \
+    value [al] \
+    modify exact [ax];
+#endif
+
+#undef      ASMAtomicCmpXchgU32
+#ifdef IPRT_ASM_WATCOM_X86_16_WITH_PRAGMAS
+#pragma aux ASMAtomicCmpXchgU32 = \
+    ".486" \
+    "shl ecx, 16" \
+    "mov cx, dx" \
+    "shl eax, 16" \
+    "mov ax, di" \
+    "rol eax, 16" \
+    "lock cmpxchg es:[bx], ecx" \
+    "setz al" \
+    parm [es bx] [cx dx] [ax di] \
+    value [al] \
+    modify exact [ax cx];
+#endif
+
+/* ASMAtomicCmpXchgU64: External assembly implementation, too few registers for parameters.  */
+/* ASMAtomicCmpXchgExU32: External assembly implementation, too few registers for parameters.  */
+/* ASMAtomicCmpXchgExU64: External assembly implementation, too few registers for parameters.  */
+
+#undef      ASMSerializeInstructionCpuId
+#ifdef IPRT_ASM_WATCOM_X86_16_WITH_PRAGMAS
+#pragma aux ASMSerializeInstructionCpuId = \
+    ".586" \
+    "xor eax, eax" \
+    "cpuid" \
+    parm [] \
+    modify exact [ax bx cx dx];
+#endif
+
+#undef ASMSerializeInstructionIRet
+#ifdef IPRT_ASM_WATCOM_X86_16_WITH_PRAGMAS
+#pragma aux ASMSerializeInstructionIRet = \
+    "pushf" \
+    "push cs" \
+    "call foo" /* 'push offset done' doesn't work */ \
+    "jmp  done" \
+    "foo:" \
+    "iret" \
+    "done:" \
+    parm [] \
+    modify exact [];
+#endif
+
+#undef      ASMSerializeInstructionRdTscp
+#ifdef IPRT_ASM_WATCOM_X86_16_WITH_PRAGMAS
+#pragma aux ASMSerializeInstructionRdTscp = \
+    0x0f 0x01 0xf9 \
+    parm [] \
+    modify exact [ax dx cx];
+#endif
+
+#undef      ASMAtomicReadU64
+#ifdef IPRT_ASM_WATCOM_X86_16_WITH_PRAGMAS
+#pragma aux ASMAtomicReadU64 = \
+    ".586" \
+    "xor eax, eax" \
+    "xor edx, edx" \
+    "xor ebx, ebx" \
+    "xor ecx, ecx" \
+    "lock cmpxchg8b es:[si]" \
+    "xchg eax, edx" \
+    "mov  ebx, eax" \
+    "shr  eax, 16" \
+    "mov  ecx, edx" \
+    "shr  ecx, 16" \
+    parm [es si] \
+    value [dx cx bx ax] \
+    modify exact [dx cx bx ax];
+#endif
+
+#undef      ASMAtomicUoReadU64
+#ifdef IPRT_ASM_WATCOM_X86_16_WITH_PRAGMAS
+#pragma aux ASMAtomicUoReadU64 = \
+    ".586" \
+    "xor eax, eax" \
+    "xor edx, edx" \
+    "xor ebx, ebx" \
+    "xor ecx, ecx" \
+    "lock cmpxchg8b es:[si]" \
+    "xchg eax, edx" \
+    "mov  ebx, eax" \
+    "shr  eax, 16" \
+    "mov  ecx, edx" \
+    "shr  ecx, 16" \
+    parm [es si] \
+    value [dx cx bx ax] \
+    modify exact [dx cx bx ax];
+#endif
+
+#undef      ASMAtomicAddU16
+#ifdef IPRT_ASM_WATCOM_X86_16_WITH_PRAGMAS
+#pragma aux ASMAtomicAddU16 = \
+    ".486" \
+    "lock xadd es:[bx], ax" \
+    parm [es bx] [ax] \
+    value [ax] \
+    modify exact [ax];
+#endif
+
+#undef      ASMAtomicAddU32
+#ifdef IPRT_ASM_WATCOM_X86_16_WITH_PRAGMAS
+#pragma aux ASMAtomicAddU32 = \
+    ".486" \
+    "shl edx, 16" \
+    "mov dx, ax" \
+    "lock xadd es:[bx], edx" \
+    "mov ax, dx" \
+    "shr edx, 16" \
+    parm [es bx] [ax dx] \
+    value [ax dx] \
+    modify exact [ax dx];
+#endif
+
+#undef      ASMAtomicIncU16
+#ifdef IPRT_ASM_WATCOM_X86_16_WITH_PRAGMAS
+#pragma aux ASMAtomicIncU16 = \
+    ".486" \
+    "mov ax, 1" \
+    "lock xadd es:[bx], ax" \
+    "inc ax" \
+    parm [es bx] \
+    value [ax] \
+    modify exact [ax];
+#endif
+
+#undef      ASMAtomicIncU32
+#ifdef IPRT_ASM_WATCOM_X86_16_WITH_PRAGMAS
+#pragma aux ASMAtomicIncU32 = \
+    ".486" \
+    "mov edx, 1" \
+    "lock xadd es:[bx], edx" \
+    "inc edx" \
+    "mov ax, dx" \
+    "shr edx, 16" \
+    parm [es bx] \
+    value [ax dx] \
+    modify exact [ax dx];
+#endif
+
+/* ASMAtomicIncU64: Should be done by C inline or in external file. */
+
+#undef      ASMAtomicDecU16
+#ifdef IPRT_ASM_WATCOM_X86_16_WITH_PRAGMAS
+#pragma aux ASMAtomicDecU16 = \
+    ".486" \
+    "mov ax, 0ffffh" \
+    "lock xadd es:[bx], ax" \
+    "dec ax" \
+    parm [es bx] \
+    value [ax] \
+    modify exact [ax];
+#endif
+
+#undef      ASMAtomicDecU32
+#ifdef IPRT_ASM_WATCOM_X86_16_WITH_PRAGMAS
+#pragma aux ASMAtomicDecU32 = \
+    ".486" \
+    "mov edx, 0ffffffffh" \
+    "lock xadd es:[bx], edx" \
+    "dec edx" \
+    "mov ax, dx" \
+    "shr edx, 16" \
+    parm [es bx] \
+    value [ax dx] \
+    modify exact [ax dx];
+#endif
+
+/* ASMAtomicDecU64: Should be done by C inline or in external file. */
+
+#undef      ASMAtomicOrU32
+#ifdef IPRT_ASM_WATCOM_X86_16_WITH_PRAGMAS
+#pragma aux ASMAtomicOrU32 = \
+    ".386" \
+    "shl edx, 16" \
+    "mov dx, ax" \
+    "lock or es:[bx], edx" \
+    parm [es bx] [ax dx] \
+    modify exact [dx];
+#endif
+
+/* ASMAtomicOrU64: Should be done by C inline or in external file. */
+
+#undef      ASMAtomicAndU32
+#ifdef IPRT_ASM_WATCOM_X86_16_WITH_PRAGMAS
+#pragma aux ASMAtomicAndU32 = \
+    ".386" \
+    "shl edx, 16" \
+    "mov dx, ax" \
+    "lock and es:[bx], edx" \
+    parm [es bx] [ax dx] \
+    modify exact [dx];
+#endif
+
+/* ASMAtomicAndU64: Should be done by C inline or in external file. */
+
+#undef      ASMAtomicUoOrU32
+#ifdef IPRT_ASM_WATCOM_X86_16_WITH_PRAGMAS
+#pragma aux ASMAtomicUoOrU32 = \
+    ".386" \
+    "shl edx, 16" \
+    "mov dx, ax" \
+    "or es:[bx], edx" \
+    parm [es bx] [ax dx] \
+    modify exact [dx];
+#endif
+
+/* ASMAtomicUoOrU64: Should be done by C inline or in external file. */
+
+#undef      ASMAtomicUoAndU32
+#ifdef IPRT_ASM_WATCOM_X86_16_WITH_PRAGMAS
+#pragma aux ASMAtomicUoAndU32 = \
+    ".386" \
+    "shl edx, 16" \
+    "mov dx, ax" \
+    "and es:[bx], edx" \
+    parm [es bx] [ax dx] \
+    modify exact [dx];
+#endif
+
+/* ASMAtomicUoAndU64: Should be done by C inline or in external file. */
+
+#undef      ASMAtomicUoIncU32
+#ifdef IPRT_ASM_WATCOM_X86_16_WITH_PRAGMAS
+#pragma aux ASMAtomicUoIncU32 = \
+    ".486" \
+    "mov edx, 1" \
+    "xadd es:[bx], edx" \
+    "inc edx" \
+    "mov ax, dx" \
+    "shr edx, 16" \
+    parm [es bx] \
+    value [ax dx] \
+    modify exact [ax dx];
+#endif
+
+#undef      ASMAtomicUoDecU32
+#ifdef IPRT_ASM_WATCOM_X86_16_WITH_PRAGMAS
+#pragma aux ASMAtomicUoDecU32 = \
+    ".486" \
+    "mov edx, 0ffffffffh" \
+    "xadd es:[bx], edx" \
+    "dec edx" \
+    "mov ax, dx" \
+    "shr edx, 16" \
+    parm [es bx] \
+    value [ax dx] \
+    modify exact [ax dx];
+#endif
+
+#undef      ASMMemZeroPage
+#ifdef IPRT_ASM_WATCOM_X86_16_WITH_PRAGMAS
+# if defined(__SW_0) || defined(__SW_1) || defined(__SW_2)
+#  pragma aux ASMMemZeroPage = \
+    "mov cx, 2048" \
+    "xor ax, ax" \
+    "rep stosw"  \
+    parm [es di] \
+    modify exact [ax cx di];
+# else
+#  pragma aux ASMMemZeroPage = \
+    "mov ecx, 1024" \
+    "xor eax, eax" \
+    "rep stosd"  \
+    parm [es di] \
+    modify exact [ax cx di];
+# endif
+#endif
+
+#undef      ASMMemZero32
+#ifdef IPRT_ASM_WATCOM_X86_16_WITH_PRAGMAS
+# if defined(__SW_0) || defined(__SW_1) || defined(__SW_2)
+#  pragma aux ASMMemZero32 = \
+    "xor ax, ax" \
+    "shr cx, 1" \
+    "shr cx, 1" \
+    "rep stosw" \
+    parm [es di] [cx] \
+    modify exact [ax dx cx di];
+# else
+#  pragma aux ASMMemZero32 = \
+    "and ecx, 0ffffh" /* probably not necessary, lazy bird should check... */ \
+    "shr ecx, 2" \
+    "xor eax, eax" \
+    "rep stosd"  \
+    parm [es di] [cx] \
+    modify exact [ax cx di];
+# endif
+#endif
+
+#undef      ASMMemFill32
+#ifdef IPRT_ASM_WATCOM_X86_16_WITH_PRAGMAS
+# if defined(__SW_0) || defined(__SW_1) || defined(__SW_2)
+#  pragma aux ASMMemFill32 = \
+    "   shr     cx, 1" \
+    "   shr     cx, 1" \
+    "   jz      done" \
+    "again:" \
+    "   stosw" \
+    "   xchg    ax, dx" \
+    "   stosw" \
+    "   xchg    ax, dx" \
+    "   dec     cx" \
+    "   jnz     again" \
+    "done:" \
+    parm [es di] [cx] [ax dx]\
+    modify exact [cx di];
+# else
+#  pragma aux ASMMemFill32 = \
+    "and ecx, 0ffffh" /* probably not necessary, lazy bird should check... */ \
+    "shr ecx, 2" \
+    "shl eax, 16" \
+    "mov ax, dx" \
+    "rol eax, 16" \
+    "rep stosd"  \
+    parm [es di] [cx] [ax dx]\
+    modify exact [ax cx di];
+# endif
+#endif
+
+#undef      ASMProbeReadByte
+#ifdef IPRT_ASM_WATCOM_X86_16_WITH_PRAGMAS
+#pragma aux ASMProbeReadByte = \
+    "mov al, es:[bx]" \
+    parm [es bx] \
+    value [al] \
+    modify exact [al];
+#endif
+
+#undef      ASMBitSet
+#ifdef IPRT_ASM_WATCOM_X86_16_WITH_PRAGMAS
+# if defined(__SW_0) || defined(__SW_1) || defined(__SW_2)
+#  pragma aux ASMBitSet = \
+    "   mov     ch, cl" /* Only the three lowest bits are relevant due to 64KB segments */ \
+    "   mov     cl, 5" \
+    "   shl     ch, cl" \
+    "   add     bh, ch" /* Adjust the pointer. */ \
+    "   mov     cl, al" \
+    "   shr     ax, 1"  /* convert to byte offset */ \
+    "   shr     ax, 1" \
+    "   shr     ax, 1" \
+    "   add     bx, ax" /* adjust pointer again */\
+    "   and     cl, 7" \
+    "   mov     al, 1" \
+    "   shl     al, cl" /* al=bitmask */ \
+    "   or      es:[bx], al" \
+    parm [es bx] [ax cx] \
+    modify exact [ax bx cx];
+# else
+#  pragma aux ASMBitSet = \
+    "shl edx, 16" \
+    "mov dx, ax" \
+    "bts es:[bx], edx" \
+    parm [es bx] [ax dx] \
+    modify exact [dx];
+# endif
+#endif
+
+#undef      ASMAtomicBitSet
+#ifdef IPRT_ASM_WATCOM_X86_16_WITH_PRAGMAS
+#pragma aux ASMAtomicBitSet = \
+    ".386" \
+    "shl edx, 16" \
+    "mov dx, ax" \
+    "lock bts es:[bx], edx" \
+    parm [es bx] [ax dx] \
+    modify exact [dx];
+#endif
+
+#undef      ASMBitClear
+#ifdef IPRT_ASM_WATCOM_X86_16_WITH_PRAGMAS
+# if defined(__SW_0) || defined(__SW_1) || defined(__SW_2)
+#  pragma aux ASMBitClear = \
+    "   mov     ch, cl" /* Only the three lowest bits are relevant due to 64KB segments */ \
+    "   mov     cl, 5" \
+    "   shl     ch, cl" \
+    "   add     bh, ch" /* Adjust the pointer. */ \
+    "   mov     cl, al" \
+    "   shr     ax, 1"  /* convert to byte offset */ \
+    "   shr     ax, 1" \
+    "   shr     ax, 1" \
+    "   add     bx, ax" /* adjust pointer again */\
+    "   and     cl, 7" \
+    "   mov     al, 1" \
+    "   shl     al, cl" \
+    "   not     al" /* al=bitmask */ \
+    "   and     es:[bx], al" \
+    parm [es bx] [ax cx] \
+    modify exact [ax bx cx];
+# else
+#  pragma aux ASMBitClear = \
+    "shl edx, 16" \
+    "mov dx, ax" \
+    "btr es:[bx], edx" \
+    parm [es bx] [ax dx] \
+    modify exact [dx];
+# endif
+#endif
+
+#undef      ASMAtomicBitClear
+#ifdef IPRT_ASM_WATCOM_X86_16_WITH_PRAGMAS
+#pragma aux ASMAtomicBitClear = \
+    ".386" \
+    "shl edx, 16" \
+    "mov dx, ax" \
+    "lock btr es:[bx], edx" \
+    parm [es bx] [ax dx] \
+    modify exact [dx];
+#endif
+
+#undef      ASMBitToggle
+#ifdef IPRT_ASM_WATCOM_X86_16_WITH_PRAGMAS
+# if defined(__SW_0) || defined(__SW_1) || defined(__SW_2)
+#  pragma aux ASMBitToggle = \
+    "   mov     ch, cl" /* Only the three lowest bits are relevant due to 64KB segments */ \
+    "   mov     cl, 5" \
+    "   shl     ch, cl" \
+    "   add     bh, ch" /* Adjust the pointer. */ \
+    "   mov     cl, al" \
+    "   shr     ax, 1"  /* convert to byte offset */ \
+    "   shr     ax, 1" \
+    "   shr     ax, 1" \
+    "   add     bx, ax" /* adjust pointer again */\
+    "   and     cl, 7" \
+    "   mov     al, 1" \
+    "   shl     al, cl" /* al=bitmask */ \
+    "   xor     es:[bx], al" \
+    parm [es bx] [ax cx] \
+    modify exact [ax bx cx];
+# else
+#  pragma aux ASMBitToggle = \
+    "shl edx, 16" \
+    "mov dx, ax" \
+    "btc es:[bx], edx" \
+    parm [es bx] [ax dx] \
+    modify exact [dx];
+# endif
+#endif
+
+#undef      ASMAtomicBitToggle
+#ifdef IPRT_ASM_WATCOM_X86_16_WITH_PRAGMAS
+#pragma aux ASMAtomicBitToggle = \
+    ".386" \
+    "shl edx, 16" \
+    "mov dx, ax" \
+    "lock btc es:[bx], edx" \
+    parm [es bx] [ax dx] \
+    modify exact [dx];
+#endif
+
+#undef      ASMBitTestAndSet
+#ifdef IPRT_ASM_WATCOM_X86_16_WITH_PRAGMAS
+# if defined(__SW_0) || defined(__SW_1) || defined(__SW_2)
+#  pragma aux ASMBitTestAndSet = \
+    "   mov     ch, cl" /* Only the three lowest bits are relevant due to 64KB segments */ \
+    "   mov     cl, 5" \
+    "   shl     ch, cl" \
+    "   add     bh, ch" /* Adjust the pointer. */ \
+    "   mov     cl, al" \
+    "   shr     ax, 1"  /* convert to byte offset */ \
+    "   shr     ax, 1" \
+    "   shr     ax, 1" \
+    "   add     bx, ax" /* adjust pointer again */\
+    "   and     cl, 7" /* cl=byte shift count */ \
+    "   mov     ah, 1" \
+    "   shl     ah, cl" /* ah=bitmask */ \
+    "   mov     al, es:[bx]" \
+    "   or      ah, al" \
+    "   mov     es:[bx], ah" \
+    "   shr     al, cl" \
+    "   and     al, 1" \
+    parm [es bx] [ax cx] \
+    value [al] \
+    modify exact [ax bx cx];
+# else
+#  pragma aux ASMBitTestAndSet = \
+    "shl edx, 16" \
+    "mov dx, ax" \
+    "bts es:[bx], edx" \
+    "setc al" \
+    parm [es bx] [ax dx] \
+    value [al] \
+    modify exact [ax dx];
+# endif
+#endif
+
+#undef      ASMAtomicBitTestAndSet
+#ifdef IPRT_ASM_WATCOM_X86_16_WITH_PRAGMAS
+#pragma aux ASMAtomicBitTestAndSet = \
+    ".386" \
+    "shl edx, 16" \
+    "mov dx, ax" \
+    "lock bts es:[bx], edx" \
+    "setc al" \
+    parm [es bx] [ax dx] \
+    value [al] \
+    modify exact [ax dx];
+#endif
+
+#undef      ASMBitTestAndClear
+#ifdef IPRT_ASM_WATCOM_X86_16_WITH_PRAGMAS
+# if defined(__SW_0) || defined(__SW_1) || defined(__SW_2)
+#  pragma aux ASMBitTestAndClear = \
+    "   mov     ch, cl" /* Only the three lowest bits are relevant due to 64KB segments */ \
+    "   mov     cl, 5" \
+    "   shl     ch, cl" \
+    "   add     bh, ch" /* Adjust the pointer. */ \
+    "   mov     cl, al" \
+    "   shr     ax, 1"  /* convert to byte offset */ \
+    "   shr     ax, 1" \
+    "   shr     ax, 1" \
+    "   add     bx, ax" /* adjust pointer again */\
+    "   and     cl, 7" /* cl=byte shift count */ \
+    "   mov     ah, 1" \
+    "   shl     ah, cl" \
+    "   not     ah" /* ah=bitmask */ \
+    "   mov     al, es:[bx]" \
+    "   and     ah, al" \
+    "   mov     es:[bx], ah" \
+    "   shr     al, cl" \
+    "   and     al, 1" \
+    parm [es bx] [ax cx] \
+    value [al] \
+    modify exact [ax bx cx];
+# else
+#  pragma aux ASMBitTestAndClear = \
+    "shl edx, 16" \
+    "mov dx, ax" \
+    "btr es:[bx], edx" \
+    "setc al" \
+    parm [es bx] [ax dx] \
+    value [al] \
+    modify exact [ax dx];
+# endif
+#endif
+
+#undef      ASMAtomicBitTestAndClear
+#ifdef IPRT_ASM_WATCOM_X86_16_WITH_PRAGMAS
+#pragma aux ASMAtomicBitTestAndClear = \
+    ".386" \
+    "shl edx, 16" \
+    "mov dx, ax" \
+    "lock btr es:[bx], edx" \
+    "setc al" \
+    parm [es bx] [ax dx] \
+    value [al] \
+    modify exact [ax dx];
+#endif
+
+#undef      ASMBitTestAndToggle
+#ifdef IPRT_ASM_WATCOM_X86_16_WITH_PRAGMAS
+# if defined(__SW_0) || defined(__SW_1) || defined(__SW_2)
+#  pragma aux ASMBitTestAndToggle = \
+    "   mov     ch, cl" /* Only the three lowest bits are relevant due to 64KB segments */ \
+    "   mov     cl, 5" \
+    "   shl     ch, cl" \
+    "   add     bh, ch" /* Adjust the pointer. */ \
+    "   mov     cl, al" \
+    "   shr     ax, 1"  /* convert to byte offset */ \
+    "   shr     ax, 1" \
+    "   shr     ax, 1" \
+    "   add     bx, ax" /* adjust pointer again */\
+    "   and     cl, 7" /* cl=byte shift count */ \
+    "   mov     ah, 1" \
+    "   shl     ah, cl" /* ah=bitmask */ \
+    "   mov     al, es:[bx]" \
+    "   xor     ah, al" \
+    "   mov     es:[bx], ah" \
+    "   shr     al, cl" \
+    "   and     al, 1" \
+    parm [es bx] [ax cx] \
+    value [al] \
+    modify exact [ax bx cx];
+# else
+#  pragma aux ASMBitTestAndToggle = \
+    "shl edx, 16" \
+    "mov dx, ax" \
+    "btc es:[bx], edx" \
+    "setc al" \
+    parm [es bx] [ax dx] \
+    value [al] \
+    modify exact [ax dx];
+# endif
+#endif
+
+#undef      ASMAtomicBitTestAndToggle
+#ifdef IPRT_ASM_WATCOM_X86_16_WITH_PRAGMAS
+#pragma aux ASMAtomicBitTestAndToggle = \
+    ".386" \
+    "shl edx, 16" \
+    "mov dx, ax" \
+    "lock btc es:[bx], edx" \
+    "setc al" \
+    parm [es bx] [ax dx] \
+    value [al] \
+    modify exact [ax dx];
+#endif
+
+#undef      ASMBitTest
+#ifdef IPRT_ASM_WATCOM_X86_16_WITH_PRAGMAS
+# if defined(__SW_0) || defined(__SW_1) || defined(__SW_2)
+#  pragma aux ASMBitTest = \
+    "   mov     ch, cl" /* Only the three lowest bits are relevant due to 64KB segments */ \
+    "   mov     cl, 5" \
+    "   shl     ch, cl" \
+    "   add     bh, ch" /* Adjust the pointer. */ \
+    "   mov     cl, al" \
+    "   shr     ax, 1"  /* convert to byte offset */ \
+    "   shr     ax, 1" \
+    "   shr     ax, 1" \
+    "   add     bx, ax" /* adjust pointer again */\
+    "   and     cl, 7" \
+    "   mov     al, es:[bx]" \
+    "   shr     al, cl" \
+    "   and     al, 1" \
+    parm [es bx] [ax cx] \
+    value [al] \
+    modify exact [ax bx cx];
+# else
+#  pragma aux ASMBitTest = \
+    "shl edx, 16" \
+    "mov dx, ax" \
+    "bt  es:[bx], edx" \
+    "setc al" \
+    parm [es bx] [ax dx] nomemory \
+    value [al] \
+    modify exact [ax dx] nomemory;
+# endif
+#endif
+
+/* ASMBitFirstClear: External file.  */
+/* ASMBitNextClear:  External file.  */
+/* ASMBitFirstSet:   External file.  */
+/* ASMBitNextSet:    External file.  */
+
+#if defined(__SW_0) || defined(__SW_1) || defined(__SW_2)
+/* ASMBitFirstSetU32: External file. */
+#else
+# undef      ASMBitFirstSetU32
+# ifdef IPRT_ASM_WATCOM_X86_16_WITH_PRAGMAS
+# pragma aux ASMBitFirstSetU32 = \
+    "shl edx, 16" \
+    "mov dx, ax" \
+    "bsf eax, edx" \
+    "jz  not_found" \
+    "inc ax" \
+    "jmp done" \
+    "not_found:" \
+    "xor ax, ax" \
+    "done:" \
+    parm [ax dx] nomemory \
+    value [ax] \
+    modify exact [ax dx] nomemory;
+# endif
+#endif
+
+#if defined(__SW_0) || defined(__SW_1) || defined(__SW_2)
+/* ASMBitFirstSetU64: External file. */
+#else
+# undef      ASMBitFirstSetU64
+# ifdef IPRT_ASM_WATCOM_X86_16_WITH_PRAGMAS
+# pragma aux ASMBitFirstSetU64 = \
+    ".386" \
+    "shl ecx, 16" \
+    "mov cx, dx" \
+    "bsf ecx, ecx" \
+    "jz  not_found_low" \
+    "mov ax, cx" \
+    "inc ax" \
+    "jmp done" \
+    \
+    "not_found_low:" \
+    "shr eax, 16" \
+    "mov ax, bx" \
+    "bsf eax, eax" \
+    "jz  not_found_high" \
+    "add ax, 33" \
+    "jmp done" \
+    \
+    "not_found_high:" \
+    "xor ax, ax" \
+    "done:" \
+    parm [dx cx bx ax] nomemory \
+    value [ax] \
+    modify exact [ax cx] nomemory;
+# endif
+#endif
+
+#if defined(__SW_0) || defined(__SW_1) || defined(__SW_2)
+/* ASMBitFirstSetU16: External file. */
+#else
+# undef      ASMBitFirstSetU16
+# ifdef IPRT_ASM_WATCOM_X86_16_WITH_PRAGMAS
+# pragma aux ASMBitFirstSetU16 = \
+    "bsf ax, ax" \
+    "jz  not_found" \
+    "inc ax" \
+    "jmp done" \
+    "not_found:" \
+    "xor ax, ax" \
+    "done:" \
+    parm [ax] nomemory \
+    value [ax] \
+    modify exact [ax] nomemory;
+# endif
+#endif
+
+#if defined(__SW_0) || defined(__SW_1) || defined(__SW_2)
+/* ASMBitLastSetU32: External file. */
+#else
+# undef      ASMBitLastSetU32
+# ifdef IPRT_ASM_WATCOM_X86_16_WITH_PRAGMAS
+# pragma aux ASMBitLastSetU32 = \
+    "shl edx, 16" \
+    "mov dx, ax" \
+    "bsr eax, edx" \
+    "jz  not_found" \
+    "inc ax" \
+    "jmp done" \
+    "not_found:" \
+    "xor ax, ax" \
+    "done:" \
+    parm [ax dx] nomemory \
+    value [ax] \
+    modify exact [ax dx] nomemory;
+# endif
+#endif
+
+#if defined(__SW_0) || defined(__SW_1) || defined(__SW_2)
+/* ASMBitLastSetU64: External file. */
+#else
+# undef      ASMBitLastSetU64
+# ifdef IPRT_ASM_WATCOM_X86_16_WITH_PRAGMAS
+# pragma aux ASMBitLastSetU64 = \
+    ".386" \
+    "shl ecx, 16" \
+    "mov cx, dx" \
+    "bsf ecx, ecx" \
+    "jz  not_found_low" \
+    "mov ax, cx" \
+    "inc ax" \
+    "jmp done" \
+    \
+    "not_found_low:" \
+    "shr eax, 16" \
+    "mov ax, bx" \
+    "bsf eax, eax" \
+    "jz  not_found_high" \
+    "add ax, 33" \
+    "jmp done" \
+    \
+    "not_found_high:" \
+    "xor ax, ax" \
+    "done:" \
+    parm [dx cx bx ax] nomemory \
+    value [ax] \
+    modify exact [ax cx] nomemory;
+# endif
+#endif
+
+#if defined(__SW_0) || defined(__SW_1) || defined(__SW_2)
+/* ASMBitLastSetU16: External file. */
+#else
+# undef      ASMBitLastSetU16
+# ifdef IPRT_ASM_WATCOM_X86_16_WITH_PRAGMAS
+# pragma aux ASMBitLastSetU16 = \
+    "bsr ax, ax" \
+    "jz  not_found" \
+    "inc ax" \
+    "jmp done" \
+    "not_found:" \
+    "xor ax, ax" \
+    "done:" \
+    parm [ax] nomemory \
+    value [ax] \
+    modify exact [ax] nomemory;
+# endif
+#endif
+
+#undef      ASMByteSwapU16
+#ifdef IPRT_ASM_WATCOM_X86_16_WITH_PRAGMAS
+#pragma aux ASMByteSwapU16 = \
+    "xchg al, ah" \
+    parm [ax] nomemory \
+    value [ax] \
+    modify exact [ax] nomemory;
+#endif
+
+#undef      ASMByteSwapU32
+#ifdef IPRT_ASM_WATCOM_X86_16_WITH_PRAGMAS
+#pragma aux ASMByteSwapU32 = \
+    "xchg dh, al" \
+    "xchg dl, ah" \
+    parm [ax dx] nomemory \
+    value [ax dx] \
+    modify exact [ax dx] nomemory;
+#endif
+
+#undef      ASMRotateLeftU32
+#ifdef IPRT_ASM_WATCOM_X86_16_WITH_PRAGMAS
+#pragma aux ASMRotateLeftU32 = \
+    ".386" \
+    "shl    edx, 16" \
+    "mov    dx, ax" \
+    "rol    edx, cl" \
+    "mov    eax, edx" \
+    "shr    edx, 16" \
+    parm [ax dx] [cx] nomemory \
+    value [ax dx] \
+    modify exact [ax dx] nomemory;
+#endif
+
+#undef      ASMRotateRightU32
+#ifdef IPRT_ASM_WATCOM_X86_16_WITH_PRAGMAS
+#pragma aux ASMRotateRightU32 = \
+    ".386" \
+    "shl    edx, 16" \
+    "mov    dx, ax" \
+    "ror    edx, cl" \
+    "mov    eax, edx" \
+    "shr    edx, 16" \
+    parm [ax dx] [cx] nomemory \
+    value [ax dx] \
+    modify exact [ax dx] nomemory;
+#endif
+
+#endif /* !IPRT_INCLUDED_asm_watcom_x86_16_h */