VirtualBox

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

Last change on this file since 63313 was 62473, checked in by vboxsync, 8 years ago

(C) 2016

  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 15.0 KB
Line 
1/** @file
2 * IPRT - AMD64 and x86 Specific Assembly Functions, 16-bit Watcom C pragma aux.
3 */
4
5/*
6 * Copyright (C) 2006-2016 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_asm_amd64_x86_h
27# error "Don't include this header directly."
28#endif
29#ifndef ___iprt_asm_amd64_x86_watcom_16_h
30#define ___iprt_asm_amd64_x86_watcom_16_h
31
32#if !RT_FAR_DATA
33# error "Only works with far data pointers!"
34#endif
35
36/*
37 * Turns out we cannot use 'ds' for segment stuff here because the compiler
38 * seems to insists on loading the DGROUP segment into 'ds' before calling
39 * stuff when using -ecc. Using 'es' instead as this seems to work fine.
40 *
41 * Note! The #undef that preceds the #pragma aux statements is for undoing
42 * the mangling, because the symbol in #pragma aux [symbol] statements
43 * doesn't get subjected to preprocessing. This is also why we include
44 * the watcom header at the top rather than at the bottom of the
45 * asm-amd64-x86.h file.
46 */
47
48#undef ASMGetIDTR
49#pragma aux ASMGetIDTR = \
50 ".286p" \
51 "sidt fword ptr es:[bx]" \
52 parm [es bx] \
53 modify exact [];
54
55#undef ASMGetIdtrLimit
56#pragma aux ASMGetIdtrLimit = \
57 ".286p" \
58 "sub sp, 8" \
59 "mov bx, sp" \
60 "sidt fword ptr ss:[bx]" \
61 "mov bx, ss:[bx]" \
62 "add sp, 8" \
63 parm [] \
64 value [bx] \
65 modify exact [bx];
66
67#undef ASMSetIDTR
68#pragma aux ASMSetIDTR = \
69 ".286p" \
70 "lidt fword ptr es:[bx]" \
71 parm [es bx] nomemory \
72 modify nomemory;
73
74#undef ASMGetGDTR
75#pragma aux ASMGetGDTR = \
76 ".286p" \
77 "sgdt fword ptr es:[bx]" \
78 parm [es bx] \
79 modify exact [];
80
81#undef ASMSetGDTR
82#pragma aux ASMSetGDTR = \
83 ".286p" \
84 "lgdt fword ptr es:[bx]" \
85 parm [es bx] nomemory \
86 modify exact [] nomemory;
87
88#undef ASMGetCS
89#pragma aux ASMGetCS = \
90 "mov ax, cs" \
91 parm [] nomemory \
92 value [ax] \
93 modify exact [ax] nomemory;
94
95#undef ASMGetDS
96#pragma aux ASMGetDS = \
97 "mov ax, ds" \
98 parm [] nomemory \
99 value [ax] \
100 modify exact [ax] nomemory;
101
102#undef ASMGetES
103#pragma aux ASMGetES = \
104 "mov ax, es" \
105 parm [] nomemory \
106 value [ax] \
107 modify exact [ax] nomemory;
108
109#undef ASMGetFS
110#pragma aux ASMGetFS = \
111 ".386" \
112 "mov ax, fs" \
113 parm [] nomemory \
114 value [ax] \
115 modify exact [ax] nomemory;
116
117#undef ASMGetGS
118#pragma aux ASMGetGS = \
119 ".386" \
120 "mov ax, gs" \
121 parm [] nomemory \
122 value [ax] \
123 modify exact [ax] nomemory;
124
125#undef ASMGetSS
126#pragma aux ASMGetSS = \
127 "mov ax, ss" \
128 parm [] nomemory \
129 value [ax] \
130 modify exact [ax] nomemory;
131
132#undef ASMGetTR
133#pragma aux ASMGetTR = \
134 ".286" \
135 "str ax" \
136 parm [] nomemory \
137 value [ax] \
138 modify exact [ax] nomemory;
139
140#undef ASMGetLDTR
141#pragma aux ASMGetLDTR = \
142 ".286" \
143 "sldt ax" \
144 parm [] nomemory \
145 value [ax] \
146 modify exact [ax] nomemory;
147
148/** @todo ASMGetSegAttr */
149
150#undef ASMGetFlags
151#pragma aux ASMGetFlags = \
152 "pushf" \
153 "pop ax" \
154 parm [] nomemory \
155 value [ax] \
156 modify exact [ax] nomemory;
157
158#undef ASMSetFlags
159#pragma aux ASMSetFlags = \
160 "push ax" \
161 "popf" \
162 parm [ax] nomemory \
163 modify exact [] nomemory;
164
165#undef ASMChangeFlags
166#pragma aux ASMChangeFlags = \
167 "pushf" \
168 "pop ax" \
169 "and dx, ax" \
170 "or dx, cx" \
171 "push dx" \
172 "popf" \
173 parm [dx] [cx] nomemory \
174 value [ax] \
175 modify exact [dx] nomemory;
176
177#undef ASMAddFlags
178#pragma aux ASMAddFlags = \
179 "pushf" \
180 "pop ax" \
181 "or dx, ax" \
182 "push dx" \
183 "popf" \
184 parm [dx] nomemory \
185 value [ax] \
186 modify exact [dx] nomemory;
187
188#undef ASMClearFlags
189#pragma aux ASMClearFlags = \
190 "pushf" \
191 "pop ax" \
192 "and dx, ax" \
193 "push dx" \
194 "popf" \
195 parm [dx] nomemory \
196 value [ax] \
197 modify exact [dx] nomemory;
198
199/* Note! Must use the 64-bit integer return value convension.
200 The order of registers in the value [set] does not seem to mean anything. */
201#undef ASMReadTSC
202#pragma aux ASMReadTSC = \
203 ".586" \
204 "rdtsc" \
205 "mov ebx, edx" \
206 "mov ecx, eax" \
207 "shr ecx, 16" \
208 "xchg eax, edx" \
209 "shr eax, 16" \
210 parm [] nomemory \
211 value [dx cx bx ax] \
212 modify exact [ax bx cx dx] nomemory;
213
214/** @todo ASMReadTscWithAux if needed (rdtscp not recognized by compiler) */
215
216
217/* ASMCpuId: Implemented externally, too many parameters. */
218/* ASMCpuId_Idx_ECX: Implemented externally, too many parameters. */
219/* ASMCpuIdExSlow: Always implemented externally. */
220/* ASMCpuId_ECX_EDX: Implemented externally, too many parameters. */
221
222#undef ASMCpuId_EAX
223#pragma aux ASMCpuId_EAX = \
224 ".586" \
225 "xchg ax, dx" \
226 "shl eax, 16" \
227 "mov ax, dx" \
228 "cpuid" \
229 "mov edx, eax" \
230 "shr edx, 16" \
231 parm [ax dx] \
232 value [ax dx] \
233 modify exact [ax bx cx dx];
234
235#undef ASMCpuId_EBX
236#pragma aux ASMCpuId_EBX = \
237 ".586" \
238 "xchg ax, dx" \
239 "shl eax, 16" \
240 "mov ax, dx" \
241 "cpuid" \
242 "mov ax, bx" \
243 "shr ebx, 16" \
244 parm [ax dx] \
245 value [ax bx] \
246 modify exact [ax bx cx dx];
247
248#undef ASMCpuId_ECX
249#pragma aux ASMCpuId_ECX = \
250 ".586" \
251 "xchg ax, dx" \
252 "shl eax, 16" \
253 "mov ax, dx" \
254 "cpuid" \
255 "mov ax, cx" \
256 "shr ecx, 16" \
257 parm [ax dx] \
258 value [ax cx] \
259 modify exact [ax bx cx dx];
260
261#undef ASMCpuId_EDX
262#pragma aux ASMCpuId_EDX = \
263 ".586" \
264 "xchg ax, dx" \
265 "shl eax, 16" \
266 "mov ax, dx" \
267 "cpuid" \
268 "mov ax, dx" \
269 "shr edx, 16" \
270 parm [ax dx] \
271 value [ax dx] \
272 modify exact [ax bx cx dx];
273
274/* ASMHasCpuId: MSC inline in main source file. */
275/* ASMGetApicId: Implemented externally, lazy bird. */
276
277/* Note! Again, when returning two registers, watcom have certain fixed ordering rules (low:high):
278 ax:bx, ax:cx, ax:dx, ax:si, ax:di
279 bx:cx, bx:dx, bx:si, bx:di
280 dx:cx, si:cx, di:cx
281 si:dx, di:dx
282 si:di
283 This ordering seems to apply to parameter values too. */
284#undef ASMGetCR0
285#pragma aux ASMGetCR0 = \
286 ".386" \
287 "mov eax, cr0" \
288 "mov edx, eax" \
289 "shr edx, 16" \
290 parm [] nomemory \
291 value [ax dx] \
292 modify exact [ax dx] nomemory;
293
294#undef ASMSetCR0
295#pragma aux ASMSetCR0 = \
296 ".386" \
297 "shl edx, 16" \
298 "mov dx, ax" \
299 "mov cr0, edx" \
300 parm [ax dx] nomemory \
301 modify exact [dx] nomemory;
302
303#undef ASMGetCR2
304#pragma aux ASMGetCR2 = \
305 ".386" \
306 "mov eax, cr2" \
307 "mov edx, eax" \
308 "shr edx, 16" \
309 parm [] nomemory \
310 value [ax dx] \
311 modify exact [ax dx] nomemory;
312
313#undef ASMSetCR2
314#pragma aux ASMSetCR2 = \
315 ".386" \
316 "shl edx, 16" \
317 "mov dx, ax" \
318 "mov cr2, edx" \
319 parm [ax dx] nomemory \
320 modify exact [dx] nomemory;
321
322#undef ASMGetCR3
323#pragma aux ASMGetCR3 = \
324 ".386" \
325 "mov eax, cr3" \
326 "mov edx, eax" \
327 "shr edx, 16" \
328 parm [] nomemory \
329 value [ax dx] \
330 modify exact [ax dx] nomemory;
331
332#undef ASMSetCR3
333#pragma aux ASMSetCR3 = \
334 ".386" \
335 "shl edx, 16" \
336 "mov dx, ax" \
337 "mov cr3, edx" \
338 parm [ax dx] nomemory \
339 modify exact [dx] nomemory;
340
341#undef ASMReloadCR3
342#pragma aux ASMReloadCR3 = \
343 ".386" \
344 "mov eax, cr3" \
345 "mov cr3, eax" \
346 parm [] nomemory \
347 modify exact [ax] nomemory;
348
349#undef ASMGetCR4
350#pragma aux ASMGetCR4 = \
351 ".386" \
352 "mov eax, cr4" \
353 "mov edx, eax" \
354 "shr edx, 16" \
355 parm [] nomemory \
356 value [ax dx] \
357 modify exact [ax dx] nomemory;
358
359#undef ASMSetCR4
360#pragma aux ASMSetCR4 = \
361 ".386" \
362 "shl edx, 16" \
363 "mov dx, ax" \
364 "mov cr4, edx" \
365 parm [ax dx] nomemory \
366 modify exact [dx] nomemory;
367
368/* ASMGetCR8: Don't bother for 16-bit. */
369/* ASMSetCR8: Don't bother for 16-bit. */
370
371#undef ASMIntEnable
372#pragma aux ASMIntEnable = \
373 "sti" \
374 parm [] nomemory \
375 modify exact [] nomemory;
376
377#undef ASMIntDisable
378#pragma aux ASMIntDisable = \
379 "cli" \
380 parm [] nomemory \
381 modify exact [] nomemory;
382
383#undef ASMIntDisableFlags
384#pragma aux ASMIntDisableFlags = \
385 "pushf" \
386 "cli" \
387 "pop ax" \
388 parm [] nomemory \
389 value [ax] \
390 modify exact [] nomemory;
391
392#undef ASMHalt
393#pragma aux ASMHalt = \
394 "hlt" \
395 parm [] nomemory \
396 modify exact [] nomemory;
397
398#undef ASMRdMsr
399#pragma aux ASMRdMsr = \
400 ".586" \
401 "shl ecx, 16" \
402 "mov cx, ax" \
403 "rdmsr" \
404 "mov ebx, edx" \
405 "mov ecx, eax" \
406 "shr ecx, 16" \
407 "xchg eax, edx" \
408 "shr eax, 16" \
409 parm [ax cx] nomemory \
410 value [dx cx bx ax] \
411 modify exact [ax bx cx dx] nomemory;
412
413/* ASMWrMsr: Implemented externally, lazy bird. */
414/* ASMRdMsrEx: Implemented externally, lazy bird. */
415/* ASMWrMsrEx: Implemented externally, lazy bird. */
416
417#undef ASMRdMsr_Low
418#pragma aux ASMRdMsr_Low = \
419 ".586" \
420 "shl ecx, 16" \
421 "mov cx, ax" \
422 "rdmsr" \
423 "mov edx, eax" \
424 "shr edx, 16" \
425 parm [ax cx] nomemory \
426 value [ax dx] \
427 modify exact [ax bx cx dx] nomemory;
428
429#undef ASMRdMsr_High
430#pragma aux ASMRdMsr_High = \
431 ".586" \
432 "shl ecx, 16" \
433 "mov cx, ax" \
434 "rdmsr" \
435 "mov eax, edx" \
436 "shr edx, 16" \
437 parm [ax cx] nomemory \
438 value [ax dx] \
439 modify exact [ax bx cx dx] nomemory;
440
441
442#undef ASMGetDR0
443#pragma aux ASMGetDR0 = \
444 ".386" \
445 "mov eax, dr0" \
446 "mov edx, eax" \
447 "shr edx, 16" \
448 parm [] nomemory \
449 value [ax dx] \
450 modify exact [ax dx] nomemory;
451
452#undef ASMGetDR1
453#pragma aux ASMGetDR1 = \
454 ".386" \
455 "mov eax, dr1" \
456 "mov edx, eax" \
457 "shr edx, 16" \
458 parm [] nomemory \
459 value [ax dx] \
460 modify exact [ax dx] nomemory;
461
462#undef ASMGetDR2
463#pragma aux ASMGetDR2 = \
464 ".386" \
465 "mov eax, dr2" \
466 "mov edx, eax" \
467 "shr edx, 16" \
468 parm [] nomemory \
469 value [ax dx] \
470 modify exact [ax dx] nomemory;
471
472#undef ASMGetDR3
473#pragma aux ASMGetDR3 = \
474 ".386" \
475 "mov eax, dr3" \
476 "mov edx, eax" \
477 "shr edx, 16" \
478 parm [] nomemory \
479 value [ax dx] \
480 modify exact [ax dx] nomemory;
481
482#undef ASMGetDR6
483#pragma aux ASMGetDR6 = \
484 ".386" \
485 "mov eax, dr6" \
486 "mov edx, eax" \
487 "shr edx, 16" \
488 parm [] nomemory \
489 value [ax dx] \
490 modify exact [ax dx] nomemory;
491
492#undef ASMGetAndClearDR6
493#pragma aux ASMGetAndClearDR6 = \
494 ".386" \
495 "mov edx, 0ffff0ff0h" \
496 "mov eax, dr6" \
497 "mov dr6, edx" \
498 "mov edx, eax" \
499 "shr edx, 16" \
500 parm [] nomemory \
501 value [ax dx] \
502 modify exact [ax dx] nomemory;
503
504#undef ASMGetDR7
505#pragma aux ASMGetDR7 = \
506 ".386" \
507 "mov eax, dr7" \
508 "mov edx, eax" \
509 "shr edx, 16" \
510 parm [] nomemory \
511 value [ax dx] \
512 modify exact [ax dx] nomemory;
513
514#undef ASMSetDR0
515#pragma aux ASMSetDR0 = \
516 ".386" \
517 "shl edx, 16" \
518 "mov dx, ax" \
519 "mov dr0, edx" \
520 parm [ax dx] nomemory \
521 modify exact [dx] nomemory;
522
523#undef ASMSetDR1
524#pragma aux ASMSetDR1 = \
525 ".386" \
526 "shl edx, 16" \
527 "mov dx, ax" \
528 "mov dr1, edx" \
529 parm [ax dx] nomemory \
530 modify exact [dx] nomemory;
531
532#undef ASMSetDR2
533#pragma aux ASMSetDR2 = \
534 ".386" \
535 "shl edx, 16" \
536 "mov dx, ax" \
537 "mov dr2, edx" \
538 parm [ax dx] nomemory \
539 modify exact [dx] nomemory;
540
541#undef ASMSetDR3
542#pragma aux ASMSetDR3 = \
543 ".386" \
544 "shl edx, 16" \
545 "mov dx, ax" \
546 "mov dr3, edx" \
547 parm [ax dx] nomemory \
548 modify exact [dx] nomemory;
549
550#undef ASMSetDR6
551#pragma aux ASMSetDR6 = \
552 ".386" \
553 "shl edx, 16" \
554 "mov dx, ax" \
555 "mov dr6, edx" \
556 parm [ax dx] nomemory \
557 modify exact [dx] nomemory;
558
559#undef ASMSetDR7
560#pragma aux ASMSetDR7 = \
561 ".386" \
562 "shl edx, 16" \
563 "mov dx, ax" \
564 "mov dr7, edx" \
565 parm [ax dx] nomemory \
566 modify exact [dx] nomemory;
567
568/* Yeah, could've used outp here, but this keeps the main file simpler. */
569#undef ASMOutU8
570#pragma aux ASMOutU8 = \
571 "out dx, al" \
572 parm [dx] [al] nomemory \
573 modify exact [] nomemory;
574
575#undef ASMInU8
576#pragma aux ASMInU8 = \
577 "in al, dx" \
578 parm [dx] nomemory \
579 value [al] \
580 modify exact [] nomemory;
581
582#undef ASMOutU16
583#undef ASMOutU16
584#pragma aux ASMOutU16 = \
585 "out dx, ax" \
586 parm [dx] [ax] nomemory \
587 modify exact [] nomemory;
588
589#undef ASMInU16
590#pragma aux ASMInU16 = \
591 "in ax, dx" \
592 parm [dx] nomemory \
593 value [ax] \
594 modify exact [] nomemory;
595
596#undef ASMOutU32
597#pragma aux ASMOutU32 = \
598 ".386" \
599 "shl ecx, 16" \
600 "mov cx, ax" \
601 "mov eax, ecx" \
602 "out dx, eax" \
603 parm [dx] [ax cx] nomemory \
604 modify exact [] nomemory;
605
606#undef ASMInU32
607#pragma aux ASMInU32 = \
608 ".386" \
609 "in eax, dx" \
610 "mov ecx, eax" \
611 "shr ecx, 16" \
612 parm [dx] nomemory \
613 value [ax cx] \
614 modify exact [] nomemory;
615
616#undef ASMOutStrU8
617#pragma aux ASMOutStrU8 = \
618 ".186" \
619 "mov ds, bx" \
620 "rep outsb" \
621 parm [dx] [bx si] [cx] nomemory \
622 modify exact [si cx ds] nomemory;
623
624#undef ASMInStrU8
625#pragma aux ASMInStrU8 = \
626 ".186" \
627 "rep insb" \
628 parm [dx] [es di] [cx] \
629 modify exact [di cx];
630
631#undef ASMOutStrU16
632#pragma aux ASMOutStrU16 = \
633 ".186" \
634 "mov ds, bx" \
635 "rep outsw" \
636 parm [dx] [bx si] [cx] nomemory \
637 modify exact [si cx ds] nomemory;
638
639#undef ASMInStrU16
640#pragma aux ASMInStrU16 = \
641 ".186" \
642 "rep insw" \
643 parm [dx] [es di] [cx] \
644 modify exact [di cx];
645
646#undef ASMOutStrU32
647#pragma aux ASMOutStrU32 = \
648 ".386" \
649 "mov ds, bx" \
650 "rep outsd" \
651 parm [dx] [bx si] [cx] nomemory \
652 modify exact [si cx ds] nomemory;
653
654#undef ASMInStrU32
655#pragma aux ASMInStrU32 = \
656 ".386" \
657 "rep insd" \
658 parm [dx] [es di] [cx] \
659 modify exact [di cx];
660
661#undef ASMInvalidatePage
662#pragma aux ASMInvalidatePage = \
663 ".486" \
664 "shl edx, 16" \
665 "mov dx, ax" \
666 "invlpg [edx]" \
667 parm [ax dx] \
668 modify exact [dx];
669
670#undef ASMWriteBackAndInvalidateCaches
671#pragma aux ASMWriteBackAndInvalidateCaches = \
672 ".486" \
673 "wbinvd" \
674 parm [] nomemory \
675 modify exact [] nomemory;
676
677#undef ASMInvalidateInternalCaches
678#pragma aux ASMInvalidateInternalCaches = \
679 ".486" \
680 "invd" \
681 parm [] \
682 modify exact [];
683
684#endif
685
Note: See TracBrowser for help on using the repository browser.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette