asm-watcom-x86-16.h@ 83941

Last change on this file since 83941 was 82968, checked in by vboxsync, 5 years 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.3 KB

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

Note: See TracBrowser for help on using the repository browser.

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

Download in other formats: