VirtualBox

source: vbox/trunk/include/iprt/asm-watcom-x86-16.h@ 98103

Last change on this file since 98103 was 98103, checked in by vboxsync, 17 months ago

Copyright year updates by scm.
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 24.6 KB
Line 
1/** @file
2 * IPRT - Assembly Functions, x86 16-bit Watcom C/C++ pragma aux.
3 */
4
5/*
6 * Copyright (C) 2006-2023 Oracle and/or its affiliates.
7 *
8 * This file is part of VirtualBox base platform packages, as
9 * available from https://www.virtualbox.org.
10 *
11 * This program is free software; you can redistribute it and/or
12 * modify it under the terms of the GNU General Public License
13 * as published by the Free Software Foundation, in version 3 of the
14 * License.
15 *
16 * This program is distributed in the hope that it will be useful, but
17 * WITHOUT ANY WARRANTY; without even the implied warranty of
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
19 * General Public License for more details.
20 *
21 * You should have received a copy of the GNU General Public License
22 * along with this program; if not, see <https://www.gnu.org/licenses>.
23 *
24 * The contents of this file may alternatively be used under the terms
25 * of the Common Development and Distribution License Version 1.0
26 * (CDDL), a copy of it is provided in the "COPYING.CDDL" file included
27 * in the VirtualBox distribution, in which case the provisions of the
28 * CDDL are applicable instead of those of the GPL.
29 *
30 * You may elect to license modified versions of this file under the
31 * terms and conditions of either the GPL or the CDDL or both.
32 *
33 * SPDX-License-Identifier: GPL-3.0-only OR CDDL-1.0
34 */
35
36#ifndef IPRT_INCLUDED_asm_watcom_x86_16_h
37#define IPRT_INCLUDED_asm_watcom_x86_16_h
38/* no pragma once */
39
40#ifndef IPRT_INCLUDED_asm_h
41# error "Don't include this header directly."
42#endif
43
44/*
45 * Turns out we cannot use 'ds' for segment stuff here because the compiler
46 * seems to insists on loading the DGROUP segment into 'ds' before calling
47 * stuff when using -ecc. Using 'es' instead as this seems to work fine.
48 *
49 * Note! The #undef that preceds the #pragma aux statements is for undoing
50 * the mangling, because the symbol in #pragma aux [symbol] statements
51 * doesn't get subjected to preprocessing. This is also why we include
52 * the watcom header at both the top and the bottom of asm.h file.
53 */
54
55#undef ASMCompilerBarrier
56#ifdef IPRT_ASM_WATCOM_X86_16_WITH_PRAGMAS
57# if 0 /* overkill version. */
58# pragma aux ASMCompilerBarrier = \
59 "nop" \
60 parm [] \
61 modify exact [ax bx cx dx es ds];
62# else
63# pragma aux ASMCompilerBarrier = \
64 "" \
65 parm [] \
66 modify exact [];
67# endif
68#endif
69
70#undef ASMNopPause
71#ifdef IPRT_ASM_WATCOM_X86_16_WITH_PRAGMAS
72#pragma aux ASMNopPause = \
73 ".686p" \
74 ".xmm2" \
75 "pause" \
76 parm [] nomemory \
77 modify exact [] nomemory;
78#endif
79
80#undef ASMAtomicXchgU8
81#ifdef IPRT_ASM_WATCOM_X86_16_WITH_PRAGMAS
82#pragma aux ASMAtomicXchgU8 = \
83 "xchg es:[bx], al" \
84 parm [es bx] [al] \
85 value [al] \
86 modify exact [al];
87#endif
88
89#undef ASMAtomicXchgU16
90#ifdef IPRT_ASM_WATCOM_X86_16_WITH_PRAGMAS
91#pragma aux ASMAtomicXchgU16 = \
92 "xchg es:[bx], ax" \
93 parm [es bx] [ax] \
94 value [ax] \
95 modify exact [ax];
96#endif
97
98#undef ASMAtomicXchgU32
99#ifdef IPRT_ASM_WATCOM_X86_16_WITH_PRAGMAS
100#pragma aux ASMAtomicXchgU32 = \
101 ".386" \
102 "shl ecx, 16" \
103 "mov cx, ax" \
104 "xchg es:[bx], ecx" \
105 "mov eax, ecx" \
106 "shr ecx, 16" \
107 parm [es bx] [ax cx] \
108 value [ax cx] \
109 modify exact [ax cx];
110#endif
111
112#undef ASMAtomicXchgU64
113#ifdef IPRT_ASM_WATCOM_X86_16_WITH_PRAGMAS
114#pragma aux ASMAtomicXchgU64 = \
115 ".586" \
116 "shl eax, 16" \
117 "mov ax, bx" /* eax = high dword */ \
118 "shl ecx, 16" \
119 "mov cx, dx" /* ecx = low dword */ \
120 "mov ebx, ecx" /* ebx = low */ \
121 "mov ecx, eax" /* ecx = high */ \
122 "try_again:" \
123 "lock cmpxchg8b es:[si]" \
124 "jnz try_again" \
125 "xchg eax, edx" \
126 "mov ebx, eax" \
127 "shr eax, 16" \
128 "mov ecx, edx" \
129 "shr ecx, 16" \
130 parm [es si] [dx cx bx ax] \
131 value [dx cx bx ax] \
132 modify exact [dx cx bx ax];
133#endif
134
135#undef ASMAtomicCmpXchgU8
136#ifdef IPRT_ASM_WATCOM_X86_16_WITH_PRAGMAS
137#pragma aux ASMAtomicCmpXchgU8 = \
138 ".486" \
139 "lock cmpxchg es:[bx], cl" \
140 "setz al" \
141 parm [es bx] [cl] [al] \
142 value [al] \
143 modify exact [al];
144#endif
145
146#undef ASMAtomicCmpXchgU16
147#ifdef IPRT_ASM_WATCOM_X86_16_WITH_PRAGMAS
148#pragma aux ASMAtomicCmpXchgU16 = \
149 ".486" \
150 "lock cmpxchg es:[bx], cx" \
151 "setz al" \
152 parm [es bx] [cx] [ax] \
153 value [al] \
154 modify exact [ax];
155#endif
156
157#undef ASMAtomicCmpXchgU32
158#ifdef IPRT_ASM_WATCOM_X86_16_WITH_PRAGMAS
159#pragma aux ASMAtomicCmpXchgU32 = \
160 ".486" \
161 "shl ecx, 16" \
162 "mov cx, dx" \
163 "shl eax, 16" \
164 "mov ax, di" \
165 "rol eax, 16" \
166 "lock cmpxchg es:[bx], ecx" \
167 "setz al" \
168 parm [es bx] [cx dx] [ax di] \
169 value [al] \
170 modify exact [ax cx];
171#endif
172
173/* ASMAtomicCmpXchgU64: External assembly implementation, too few registers for parameters. */
174/* ASMAtomicCmpXchgExU32: External assembly implementation, too few registers for parameters. */
175/* ASMAtomicCmpXchgExU64: External assembly implementation, too few registers for parameters. */
176
177#undef ASMSerializeInstructionCpuId
178#ifdef IPRT_ASM_WATCOM_X86_16_WITH_PRAGMAS
179#pragma aux ASMSerializeInstructionCpuId = \
180 ".586" \
181 "xor eax, eax" \
182 "cpuid" \
183 parm [] \
184 modify exact [ax bx cx dx];
185#endif
186
187#undef ASMSerializeInstructionIRet
188#ifdef IPRT_ASM_WATCOM_X86_16_WITH_PRAGMAS
189#pragma aux ASMSerializeInstructionIRet = \
190 "pushf" \
191 "push cs" \
192 "call foo" /* 'push offset done' doesn't work */ \
193 "jmp done" \
194 "foo:" \
195 "iret" \
196 "done:" \
197 parm [] \
198 modify exact [];
199#endif
200
201#undef ASMSerializeInstructionRdTscp
202#ifdef IPRT_ASM_WATCOM_X86_16_WITH_PRAGMAS
203#pragma aux ASMSerializeInstructionRdTscp = \
204 0x0f 0x01 0xf9 \
205 parm [] \
206 modify exact [ax dx cx];
207#endif
208
209#undef ASMAtomicReadU64
210#ifdef IPRT_ASM_WATCOM_X86_16_WITH_PRAGMAS
211#pragma aux ASMAtomicReadU64 = \
212 ".586" \
213 "xor eax, eax" \
214 "xor edx, edx" \
215 "xor ebx, ebx" \
216 "xor ecx, ecx" \
217 "lock cmpxchg8b es:[si]" \
218 "xchg eax, edx" \
219 "mov ebx, eax" \
220 "shr eax, 16" \
221 "mov ecx, edx" \
222 "shr ecx, 16" \
223 parm [es si] \
224 value [dx cx bx ax] \
225 modify exact [dx cx bx ax];
226#endif
227
228#undef ASMAtomicUoReadU64
229#ifdef IPRT_ASM_WATCOM_X86_16_WITH_PRAGMAS
230#pragma aux ASMAtomicUoReadU64 = \
231 ".586" \
232 "xor eax, eax" \
233 "xor edx, edx" \
234 "xor ebx, ebx" \
235 "xor ecx, ecx" \
236 "lock cmpxchg8b es:[si]" \
237 "xchg eax, edx" \
238 "mov ebx, eax" \
239 "shr eax, 16" \
240 "mov ecx, edx" \
241 "shr ecx, 16" \
242 parm [es si] \
243 value [dx cx bx ax] \
244 modify exact [dx cx bx ax];
245#endif
246
247#undef ASMAtomicAddU16
248#ifdef IPRT_ASM_WATCOM_X86_16_WITH_PRAGMAS
249#pragma aux ASMAtomicAddU16 = \
250 ".486" \
251 "lock xadd es:[bx], ax" \
252 parm [es bx] [ax] \
253 value [ax] \
254 modify exact [ax];
255#endif
256
257#undef ASMAtomicAddU32
258#ifdef IPRT_ASM_WATCOM_X86_16_WITH_PRAGMAS
259#pragma aux ASMAtomicAddU32 = \
260 ".486" \
261 "shl edx, 16" \
262 "mov dx, ax" \
263 "lock xadd es:[bx], edx" \
264 "mov ax, dx" \
265 "shr edx, 16" \
266 parm [es bx] [ax dx] \
267 value [ax dx] \
268 modify exact [ax dx];
269#endif
270
271#undef ASMAtomicIncU16
272#ifdef IPRT_ASM_WATCOM_X86_16_WITH_PRAGMAS
273#pragma aux ASMAtomicIncU16 = \
274 ".486" \
275 "mov ax, 1" \
276 "lock xadd es:[bx], ax" \
277 "inc ax" \
278 parm [es bx] \
279 value [ax] \
280 modify exact [ax];
281#endif
282
283#undef ASMAtomicIncU32
284#ifdef IPRT_ASM_WATCOM_X86_16_WITH_PRAGMAS
285#pragma aux ASMAtomicIncU32 = \
286 ".486" \
287 "mov edx, 1" \
288 "lock xadd es:[bx], edx" \
289 "inc edx" \
290 "mov ax, dx" \
291 "shr edx, 16" \
292 parm [es bx] \
293 value [ax dx] \
294 modify exact [ax dx];
295#endif
296
297/* ASMAtomicIncU64: Should be done by C inline or in external file. */
298
299#undef ASMAtomicDecU16
300#ifdef IPRT_ASM_WATCOM_X86_16_WITH_PRAGMAS
301#pragma aux ASMAtomicDecU16 = \
302 ".486" \
303 "mov ax, 0ffffh" \
304 "lock xadd es:[bx], ax" \
305 "dec ax" \
306 parm [es bx] \
307 value [ax] \
308 modify exact [ax];
309#endif
310
311#undef ASMAtomicDecU32
312#ifdef IPRT_ASM_WATCOM_X86_16_WITH_PRAGMAS
313#pragma aux ASMAtomicDecU32 = \
314 ".486" \
315 "mov edx, 0ffffffffh" \
316 "lock xadd es:[bx], edx" \
317 "dec edx" \
318 "mov ax, dx" \
319 "shr edx, 16" \
320 parm [es bx] \
321 value [ax dx] \
322 modify exact [ax dx];
323#endif
324
325/* ASMAtomicDecU64: Should be done by C inline or in external file. */
326
327#undef ASMAtomicOrU32
328#ifdef IPRT_ASM_WATCOM_X86_16_WITH_PRAGMAS
329#pragma aux ASMAtomicOrU32 = \
330 ".386" \
331 "shl edx, 16" \
332 "mov dx, ax" \
333 "lock or es:[bx], edx" \
334 parm [es bx] [ax dx] \
335 modify exact [dx];
336#endif
337
338/* ASMAtomicOrU64: Should be done by C inline or in external file. */
339
340#undef ASMAtomicAndU32
341#ifdef IPRT_ASM_WATCOM_X86_16_WITH_PRAGMAS
342#pragma aux ASMAtomicAndU32 = \
343 ".386" \
344 "shl edx, 16" \
345 "mov dx, ax" \
346 "lock and es:[bx], edx" \
347 parm [es bx] [ax dx] \
348 modify exact [dx];
349#endif
350
351/* ASMAtomicAndU64: Should be done by C inline or in external file. */
352
353#undef ASMAtomicUoOrU32
354#ifdef IPRT_ASM_WATCOM_X86_16_WITH_PRAGMAS
355#pragma aux ASMAtomicUoOrU32 = \
356 ".386" \
357 "shl edx, 16" \
358 "mov dx, ax" \
359 "or es:[bx], edx" \
360 parm [es bx] [ax dx] \
361 modify exact [dx];
362#endif
363
364/* ASMAtomicUoOrU64: Should be done by C inline or in external file. */
365
366#undef ASMAtomicUoAndU32
367#ifdef IPRT_ASM_WATCOM_X86_16_WITH_PRAGMAS
368#pragma aux ASMAtomicUoAndU32 = \
369 ".386" \
370 "shl edx, 16" \
371 "mov dx, ax" \
372 "and es:[bx], edx" \
373 parm [es bx] [ax dx] \
374 modify exact [dx];
375#endif
376
377/* ASMAtomicUoAndU64: Should be done by C inline or in external file. */
378
379#undef ASMAtomicUoIncU32
380#ifdef IPRT_ASM_WATCOM_X86_16_WITH_PRAGMAS
381#pragma aux ASMAtomicUoIncU32 = \
382 ".486" \
383 "mov edx, 1" \
384 "xadd es:[bx], edx" \
385 "inc edx" \
386 "mov ax, dx" \
387 "shr edx, 16" \
388 parm [es bx] \
389 value [ax dx] \
390 modify exact [ax dx];
391#endif
392
393#undef ASMAtomicUoDecU32
394#ifdef IPRT_ASM_WATCOM_X86_16_WITH_PRAGMAS
395#pragma aux ASMAtomicUoDecU32 = \
396 ".486" \
397 "mov edx, 0ffffffffh" \
398 "xadd es:[bx], edx" \
399 "dec edx" \
400 "mov ax, dx" \
401 "shr edx, 16" \
402 parm [es bx] \
403 value [ax dx] \
404 modify exact [ax dx];
405#endif
406
407#undef ASMMemZeroPage
408#ifdef IPRT_ASM_WATCOM_X86_16_WITH_PRAGMAS
409# if defined(__SW_0) || defined(__SW_1) || defined(__SW_2)
410# pragma aux ASMMemZeroPage = \
411 "mov cx, 2048" \
412 "xor ax, ax" \
413 "rep stosw" \
414 parm [es di] \
415 modify exact [ax cx di];
416# else
417# pragma aux ASMMemZeroPage = \
418 "mov ecx, 1024" \
419 "xor eax, eax" \
420 "rep stosd" \
421 parm [es di] \
422 modify exact [ax cx di];
423# endif
424#endif
425
426#undef ASMMemZero32
427#ifdef IPRT_ASM_WATCOM_X86_16_WITH_PRAGMAS
428# if defined(__SW_0) || defined(__SW_1) || defined(__SW_2)
429# pragma aux ASMMemZero32 = \
430 "xor ax, ax" \
431 "shr cx, 1" \
432 "shr cx, 1" \
433 "rep stosw" \
434 parm [es di] [cx] \
435 modify exact [ax dx cx di];
436# else
437# pragma aux ASMMemZero32 = \
438 "and ecx, 0ffffh" /* probably not necessary, lazy bird should check... */ \
439 "shr ecx, 2" \
440 "xor eax, eax" \
441 "rep stosd" \
442 parm [es di] [cx] \
443 modify exact [ax cx di];
444# endif
445#endif
446
447#undef ASMMemFill32
448#ifdef IPRT_ASM_WATCOM_X86_16_WITH_PRAGMAS
449# if defined(__SW_0) || defined(__SW_1) || defined(__SW_2)
450# pragma aux ASMMemFill32 = \
451 " shr cx, 1" \
452 " shr cx, 1" \
453 " jz done" \
454 "again:" \
455 " stosw" \
456 " xchg ax, dx" \
457 " stosw" \
458 " xchg ax, dx" \
459 " dec cx" \
460 " jnz again" \
461 "done:" \
462 parm [es di] [cx] [ax dx]\
463 modify exact [cx di];
464# else
465# pragma aux ASMMemFill32 = \
466 "and ecx, 0ffffh" /* probably not necessary, lazy bird should check... */ \
467 "shr ecx, 2" \
468 "shl eax, 16" \
469 "mov ax, dx" \
470 "rol eax, 16" \
471 "rep stosd" \
472 parm [es di] [cx] [ax dx]\
473 modify exact [ax cx di];
474# endif
475#endif
476
477#undef ASMProbeReadByte
478#ifdef IPRT_ASM_WATCOM_X86_16_WITH_PRAGMAS
479#pragma aux ASMProbeReadByte = \
480 "mov al, es:[bx]" \
481 parm [es bx] \
482 value [al] \
483 modify exact [al];
484#endif
485
486#undef ASMBitSet
487#ifdef IPRT_ASM_WATCOM_X86_16_WITH_PRAGMAS
488# if defined(__SW_0) || defined(__SW_1) || defined(__SW_2)
489# pragma aux ASMBitSet = \
490 " mov ch, cl" /* Only the three lowest bits are relevant due to 64KB segments */ \
491 " mov cl, 5" \
492 " shl ch, cl" \
493 " add bh, ch" /* Adjust the pointer. */ \
494 " mov cl, al" \
495 " shr ax, 1" /* convert to byte offset */ \
496 " shr ax, 1" \
497 " shr ax, 1" \
498 " add bx, ax" /* adjust pointer again */\
499 " and cl, 7" \
500 " mov al, 1" \
501 " shl al, cl" /* al=bitmask */ \
502 " or es:[bx], al" \
503 parm [es bx] [ax cx] \
504 modify exact [ax bx cx];
505# else
506# pragma aux ASMBitSet = \
507 "shl edx, 16" \
508 "mov dx, ax" \
509 "bts es:[bx], edx" \
510 parm [es bx] [ax dx] \
511 modify exact [dx];
512# endif
513#endif
514
515#undef ASMAtomicBitSet
516#ifdef IPRT_ASM_WATCOM_X86_16_WITH_PRAGMAS
517#pragma aux ASMAtomicBitSet = \
518 ".386" \
519 "shl edx, 16" \
520 "mov dx, ax" \
521 "lock bts es:[bx], edx" \
522 parm [es bx] [ax dx] \
523 modify exact [dx];
524#endif
525
526#undef ASMBitClear
527#ifdef IPRT_ASM_WATCOM_X86_16_WITH_PRAGMAS
528# if defined(__SW_0) || defined(__SW_1) || defined(__SW_2)
529# pragma aux ASMBitClear = \
530 " mov ch, cl" /* Only the three lowest bits are relevant due to 64KB segments */ \
531 " mov cl, 5" \
532 " shl ch, cl" \
533 " add bh, ch" /* Adjust the pointer. */ \
534 " mov cl, al" \
535 " shr ax, 1" /* convert to byte offset */ \
536 " shr ax, 1" \
537 " shr ax, 1" \
538 " add bx, ax" /* adjust pointer again */\
539 " and cl, 7" \
540 " mov al, 1" \
541 " shl al, cl" \
542 " not al" /* al=bitmask */ \
543 " and es:[bx], al" \
544 parm [es bx] [ax cx] \
545 modify exact [ax bx cx];
546# else
547# pragma aux ASMBitClear = \
548 "shl edx, 16" \
549 "mov dx, ax" \
550 "btr es:[bx], edx" \
551 parm [es bx] [ax dx] \
552 modify exact [dx];
553# endif
554#endif
555
556#undef ASMAtomicBitClear
557#ifdef IPRT_ASM_WATCOM_X86_16_WITH_PRAGMAS
558#pragma aux ASMAtomicBitClear = \
559 ".386" \
560 "shl edx, 16" \
561 "mov dx, ax" \
562 "lock btr es:[bx], edx" \
563 parm [es bx] [ax dx] \
564 modify exact [dx];
565#endif
566
567#undef ASMBitToggle
568#ifdef IPRT_ASM_WATCOM_X86_16_WITH_PRAGMAS
569# if defined(__SW_0) || defined(__SW_1) || defined(__SW_2)
570# pragma aux ASMBitToggle = \
571 " mov ch, cl" /* Only the three lowest bits are relevant due to 64KB segments */ \
572 " mov cl, 5" \
573 " shl ch, cl" \
574 " add bh, ch" /* Adjust the pointer. */ \
575 " mov cl, al" \
576 " shr ax, 1" /* convert to byte offset */ \
577 " shr ax, 1" \
578 " shr ax, 1" \
579 " add bx, ax" /* adjust pointer again */\
580 " and cl, 7" \
581 " mov al, 1" \
582 " shl al, cl" /* al=bitmask */ \
583 " xor es:[bx], al" \
584 parm [es bx] [ax cx] \
585 modify exact [ax bx cx];
586# else
587# pragma aux ASMBitToggle = \
588 "shl edx, 16" \
589 "mov dx, ax" \
590 "btc es:[bx], edx" \
591 parm [es bx] [ax dx] \
592 modify exact [dx];
593# endif
594#endif
595
596#undef ASMAtomicBitToggle
597#ifdef IPRT_ASM_WATCOM_X86_16_WITH_PRAGMAS
598#pragma aux ASMAtomicBitToggle = \
599 ".386" \
600 "shl edx, 16" \
601 "mov dx, ax" \
602 "lock btc es:[bx], edx" \
603 parm [es bx] [ax dx] \
604 modify exact [dx];
605#endif
606
607#undef ASMBitTestAndSet
608#ifdef IPRT_ASM_WATCOM_X86_16_WITH_PRAGMAS
609# if defined(__SW_0) || defined(__SW_1) || defined(__SW_2)
610# pragma aux ASMBitTestAndSet = \
611 " mov ch, cl" /* Only the three lowest bits are relevant due to 64KB segments */ \
612 " mov cl, 5" \
613 " shl ch, cl" \
614 " add bh, ch" /* Adjust the pointer. */ \
615 " mov cl, al" \
616 " shr ax, 1" /* convert to byte offset */ \
617 " shr ax, 1" \
618 " shr ax, 1" \
619 " add bx, ax" /* adjust pointer again */\
620 " and cl, 7" /* cl=byte shift count */ \
621 " mov ah, 1" \
622 " shl ah, cl" /* ah=bitmask */ \
623 " mov al, es:[bx]" \
624 " or ah, al" \
625 " mov es:[bx], ah" \
626 " shr al, cl" \
627 " and al, 1" \
628 parm [es bx] [ax cx] \
629 value [al] \
630 modify exact [ax bx cx];
631# else
632# pragma aux ASMBitTestAndSet = \
633 "shl edx, 16" \
634 "mov dx, ax" \
635 "bts es:[bx], edx" \
636 "setc al" \
637 parm [es bx] [ax dx] \
638 value [al] \
639 modify exact [ax dx];
640# endif
641#endif
642
643#undef ASMAtomicBitTestAndSet
644#ifdef IPRT_ASM_WATCOM_X86_16_WITH_PRAGMAS
645#pragma aux ASMAtomicBitTestAndSet = \
646 ".386" \
647 "shl edx, 16" \
648 "mov dx, ax" \
649 "lock bts es:[bx], edx" \
650 "setc al" \
651 parm [es bx] [ax dx] \
652 value [al] \
653 modify exact [ax dx];
654#endif
655
656#undef ASMBitTestAndClear
657#ifdef IPRT_ASM_WATCOM_X86_16_WITH_PRAGMAS
658# if defined(__SW_0) || defined(__SW_1) || defined(__SW_2)
659# pragma aux ASMBitTestAndClear = \
660 " mov ch, cl" /* Only the three lowest bits are relevant due to 64KB segments */ \
661 " mov cl, 5" \
662 " shl ch, cl" \
663 " add bh, ch" /* Adjust the pointer. */ \
664 " mov cl, al" \
665 " shr ax, 1" /* convert to byte offset */ \
666 " shr ax, 1" \
667 " shr ax, 1" \
668 " add bx, ax" /* adjust pointer again */\
669 " and cl, 7" /* cl=byte shift count */ \
670 " mov ah, 1" \
671 " shl ah, cl" \
672 " not ah" /* ah=bitmask */ \
673 " mov al, es:[bx]" \
674 " and ah, al" \
675 " mov es:[bx], ah" \
676 " shr al, cl" \
677 " and al, 1" \
678 parm [es bx] [ax cx] \
679 value [al] \
680 modify exact [ax bx cx];
681# else
682# pragma aux ASMBitTestAndClear = \
683 "shl edx, 16" \
684 "mov dx, ax" \
685 "btr es:[bx], edx" \
686 "setc al" \
687 parm [es bx] [ax dx] \
688 value [al] \
689 modify exact [ax dx];
690# endif
691#endif
692
693#undef ASMAtomicBitTestAndClear
694#ifdef IPRT_ASM_WATCOM_X86_16_WITH_PRAGMAS
695#pragma aux ASMAtomicBitTestAndClear = \
696 ".386" \
697 "shl edx, 16" \
698 "mov dx, ax" \
699 "lock btr es:[bx], edx" \
700 "setc al" \
701 parm [es bx] [ax dx] \
702 value [al] \
703 modify exact [ax dx];
704#endif
705
706#undef ASMBitTestAndToggle
707#ifdef IPRT_ASM_WATCOM_X86_16_WITH_PRAGMAS
708# if defined(__SW_0) || defined(__SW_1) || defined(__SW_2)
709# pragma aux ASMBitTestAndToggle = \
710 " mov ch, cl" /* Only the three lowest bits are relevant due to 64KB segments */ \
711 " mov cl, 5" \
712 " shl ch, cl" \
713 " add bh, ch" /* Adjust the pointer. */ \
714 " mov cl, al" \
715 " shr ax, 1" /* convert to byte offset */ \
716 " shr ax, 1" \
717 " shr ax, 1" \
718 " add bx, ax" /* adjust pointer again */\
719 " and cl, 7" /* cl=byte shift count */ \
720 " mov ah, 1" \
721 " shl ah, cl" /* ah=bitmask */ \
722 " mov al, es:[bx]" \
723 " xor ah, al" \
724 " mov es:[bx], ah" \
725 " shr al, cl" \
726 " and al, 1" \
727 parm [es bx] [ax cx] \
728 value [al] \
729 modify exact [ax bx cx];
730# else
731# pragma aux ASMBitTestAndToggle = \
732 "shl edx, 16" \
733 "mov dx, ax" \
734 "btc es:[bx], edx" \
735 "setc al" \
736 parm [es bx] [ax dx] \
737 value [al] \
738 modify exact [ax dx];
739# endif
740#endif
741
742#undef ASMAtomicBitTestAndToggle
743#ifdef IPRT_ASM_WATCOM_X86_16_WITH_PRAGMAS
744#pragma aux ASMAtomicBitTestAndToggle = \
745 ".386" \
746 "shl edx, 16" \
747 "mov dx, ax" \
748 "lock btc es:[bx], edx" \
749 "setc al" \
750 parm [es bx] [ax dx] \
751 value [al] \
752 modify exact [ax dx];
753#endif
754
755#undef ASMBitTest
756#ifdef IPRT_ASM_WATCOM_X86_16_WITH_PRAGMAS
757# if defined(__SW_0) || defined(__SW_1) || defined(__SW_2)
758# pragma aux ASMBitTest = \
759 " mov ch, cl" /* Only the three lowest bits are relevant due to 64KB segments */ \
760 " mov cl, 5" \
761 " shl ch, cl" \
762 " add bh, ch" /* Adjust the pointer. */ \
763 " mov cl, al" \
764 " shr ax, 1" /* convert to byte offset */ \
765 " shr ax, 1" \
766 " shr ax, 1" \
767 " add bx, ax" /* adjust pointer again */\
768 " and cl, 7" \
769 " mov al, es:[bx]" \
770 " shr al, cl" \
771 " and al, 1" \
772 parm [es bx] [ax cx] \
773 value [al] \
774 modify exact [ax bx cx];
775# else
776# pragma aux ASMBitTest = \
777 "shl edx, 16" \
778 "mov dx, ax" \
779 "bt es:[bx], edx" \
780 "setc al" \
781 parm [es bx] [ax dx] nomemory \
782 value [al] \
783 modify exact [ax dx] nomemory;
784# endif
785#endif
786
787/* ASMBitFirstClear: External file. */
788/* ASMBitNextClear: External file. */
789/* ASMBitFirstSet: External file. */
790/* ASMBitNextSet: External file. */
791
792#if defined(__SW_0) || defined(__SW_1) || defined(__SW_2)
793/* ASMBitFirstSetU32: External file. */
794#else
795# undef ASMBitFirstSetU32
796# ifdef IPRT_ASM_WATCOM_X86_16_WITH_PRAGMAS
797# pragma aux ASMBitFirstSetU32 = \
798 "shl edx, 16" \
799 "mov dx, ax" \
800 "bsf eax, edx" \
801 "jz not_found" \
802 "inc ax" \
803 "jmp done" \
804 "not_found:" \
805 "xor ax, ax" \
806 "done:" \
807 parm [ax dx] nomemory \
808 value [ax] \
809 modify exact [ax dx] nomemory;
810# endif
811#endif
812
813#if defined(__SW_0) || defined(__SW_1) || defined(__SW_2)
814/* ASMBitFirstSetU64: External file. */
815#else
816# undef ASMBitFirstSetU64
817# ifdef IPRT_ASM_WATCOM_X86_16_WITH_PRAGMAS
818# pragma aux ASMBitFirstSetU64 = \
819 ".386" \
820 "shl ecx, 16" \
821 "mov cx, dx" \
822 "bsf ecx, ecx" \
823 "jz not_found_low" \
824 "mov ax, cx" \
825 "inc ax" \
826 "jmp done" \
827 \
828 "not_found_low:" \
829 "shr eax, 16" \
830 "mov ax, bx" \
831 "bsf eax, eax" \
832 "jz not_found_high" \
833 "add ax, 33" \
834 "jmp done" \
835 \
836 "not_found_high:" \
837 "xor ax, ax" \
838 "done:" \
839 parm [dx cx bx ax] nomemory \
840 value [ax] \
841 modify exact [ax cx] nomemory;
842# endif
843#endif
844
845#if defined(__SW_0) || defined(__SW_1) || defined(__SW_2)
846/* ASMBitFirstSetU16: External file. */
847#else
848# undef ASMBitFirstSetU16
849# ifdef IPRT_ASM_WATCOM_X86_16_WITH_PRAGMAS
850# pragma aux ASMBitFirstSetU16 = \
851 "bsf ax, ax" \
852 "jz not_found" \
853 "inc ax" \
854 "jmp done" \
855 "not_found:" \
856 "xor ax, ax" \
857 "done:" \
858 parm [ax] nomemory \
859 value [ax] \
860 modify exact [ax] nomemory;
861# endif
862#endif
863
864#if defined(__SW_0) || defined(__SW_1) || defined(__SW_2)
865/* ASMBitLastSetU32: External file. */
866#else
867# undef ASMBitLastSetU32
868# ifdef IPRT_ASM_WATCOM_X86_16_WITH_PRAGMAS
869# pragma aux ASMBitLastSetU32 = \
870 "shl edx, 16" \
871 "mov dx, ax" \
872 "bsr eax, edx" \
873 "jz not_found" \
874 "inc ax" \
875 "jmp done" \
876 "not_found:" \
877 "xor ax, ax" \
878 "done:" \
879 parm [ax dx] nomemory \
880 value [ax] \
881 modify exact [ax dx] nomemory;
882# endif
883#endif
884
885#if defined(__SW_0) || defined(__SW_1) || defined(__SW_2)
886/* ASMBitLastSetU64: External file. */
887#else
888# undef ASMBitLastSetU64
889# ifdef IPRT_ASM_WATCOM_X86_16_WITH_PRAGMAS
890# pragma aux ASMBitLastSetU64 = \
891 ".386" \
892 "shl ecx, 16" \
893 "mov cx, dx" \
894 "bsf ecx, ecx" \
895 "jz not_found_low" \
896 "mov ax, cx" \
897 "inc ax" \
898 "jmp done" \
899 \
900 "not_found_low:" \
901 "shr eax, 16" \
902 "mov ax, bx" \
903 "bsf eax, eax" \
904 "jz not_found_high" \
905 "add ax, 33" \
906 "jmp done" \
907 \
908 "not_found_high:" \
909 "xor ax, ax" \
910 "done:" \
911 parm [dx cx bx ax] nomemory \
912 value [ax] \
913 modify exact [ax cx] nomemory;
914# endif
915#endif
916
917#if defined(__SW_0) || defined(__SW_1) || defined(__SW_2)
918/* ASMBitLastSetU16: External file. */
919#else
920# undef ASMBitLastSetU16
921# ifdef IPRT_ASM_WATCOM_X86_16_WITH_PRAGMAS
922# pragma aux ASMBitLastSetU16 = \
923 "bsr ax, ax" \
924 "jz not_found" \
925 "inc ax" \
926 "jmp done" \
927 "not_found:" \
928 "xor ax, ax" \
929 "done:" \
930 parm [ax] nomemory \
931 value [ax] \
932 modify exact [ax] nomemory;
933# endif
934#endif
935
936#undef ASMByteSwapU16
937#ifdef IPRT_ASM_WATCOM_X86_16_WITH_PRAGMAS
938#pragma aux ASMByteSwapU16 = \
939 "xchg al, ah" \
940 parm [ax] nomemory \
941 value [ax] \
942 modify exact [ax] nomemory;
943#endif
944
945#undef ASMByteSwapU32
946#ifdef IPRT_ASM_WATCOM_X86_16_WITH_PRAGMAS
947#pragma aux ASMByteSwapU32 = \
948 "xchg dh, al" \
949 "xchg dl, ah" \
950 parm [ax dx] nomemory \
951 value [ax dx] \
952 modify exact [ax dx] nomemory;
953#endif
954
955#undef ASMRotateLeftU32
956#ifdef IPRT_ASM_WATCOM_X86_16_WITH_PRAGMAS
957#pragma aux ASMRotateLeftU32 = \
958 ".386" \
959 "shl edx, 16" \
960 "mov dx, ax" \
961 "rol edx, cl" \
962 "mov eax, edx" \
963 "shr edx, 16" \
964 parm [ax dx] [cx] nomemory \
965 value [ax dx] \
966 modify exact [ax dx] nomemory;
967#endif
968
969#undef ASMRotateRightU32
970#ifdef IPRT_ASM_WATCOM_X86_16_WITH_PRAGMAS
971#pragma aux ASMRotateRightU32 = \
972 ".386" \
973 "shl edx, 16" \
974 "mov dx, ax" \
975 "ror edx, cl" \
976 "mov eax, edx" \
977 "shr edx, 16" \
978 parm [ax dx] [cx] nomemory \
979 value [ax dx] \
980 modify exact [ax dx] nomemory;
981#endif
982
983#endif /* !IPRT_INCLUDED_asm_watcom_x86_16_h */
Note: See TracBrowser for help on using the repository browser.

© 2023 Oracle
Contact – Privacy policy – Terms of Use