VirtualBox

source: vbox/trunk/src/VBox/VMM/VMMAll/EMAllA.asm@ 5070

Last change on this file since 5070 was 4284, checked in by vboxsync, 17 years ago

drop a double prediction and some blanks.
  • Property svn:eol-style set to native
  • Property svn:keywords set to Id
File size: 20.4 KB
Line 
1; $Id: EMAllA.asm 4284 2007-08-22 14:18:05Z vboxsync $
2;; @file
3; EM Assembly Routines.
4;
5
6;
7; Copyright (C) 2006-2007 innotek GmbH
8;
9; This file is part of VirtualBox Open Source Edition (OSE), as
10; available from http://www.virtualbox.org. This file is free software;
11; you can redistribute it and/or modify it under the terms of the GNU
12; General Public License as published by the Free Software Foundation,
13; in version 2 as it comes in the "COPYING" file of the VirtualBox OSE
14; distribution. VirtualBox OSE is distributed in the hope that it will
15; be useful, but WITHOUT ANY WARRANTY of any kind.
16
17;*******************************************************************************
18;* Header Files *
19;*******************************************************************************
20%include "VBox/asmdefs.mac"
21%include "VBox/err.mac"
22%include "VBox/x86.mac"
23
24;; @def MY_PTR_REG
25; The register we use for value pointers (And,Or,Dec,Inc).
26%ifdef RT_ARCH_AMD64
27%define MY_PTR_REG rcx
28%else
29%define MY_PTR_REG ecx
30%endif
31
32;; @def MY_RET_REG
33; The register we return the result in.
34%ifdef RT_ARCH_AMD64
35%define MY_RET_REG rax
36%else
37%define MY_RET_REG eax
38%endif
39
40BEGINCODE
41
42
43;;
44; Emulate CMP instruction, CDECL calling conv.
45; EMDECL(uint32_t) EMEmulateCmp(uint32_t u32Param1, uint32_t u32Param2, size_t cb);
46;
47; @returns EFLAGS after the operation, only arithmetic flags is valid.
48; @param [esp + 04h] rdi rcx Param 1 - First parameter (Dst).
49; @param [esp + 08h] rsi edx Param 2 - Second parameter (Src).
50; @param [esp + 0ch] rdx r8 Param 3 - Size of parameters, only 1/2/4 is valid.
51;
52align 16
53BEGINPROC EMEmulateCmp
54%ifdef RT_ARCH_AMD64
55%ifdef RT_OS_WINDOWS
56 mov rax, r8 ; eax = size of parameters
57%else ; !RT_OS_WINDOWS
58 mov rax, rdx ; rax = size of parameters
59 mov rcx, rdi ; rcx = first parameter
60 mov rdx, rsi ; rdx = second parameter
61%endif ; !RT_OS_WINDOWS
62%else ; !RT_ARCH_AMD64
63 mov eax, [esp + 0ch] ; eax = size of parameters
64 mov ecx, [esp + 04h] ; ecx = first parameter
65 mov edx, [esp + 08h] ; edx = second parameter
66%endif
67
68 ; switch on size
69%ifdef RT_ARCH_AMD64
70 cmp al, 8
71 je short .do_qword ; 8 bytes variant
72%endif
73 cmp al, 4
74 je short .do_dword ; 4 bytes variant
75 cmp al, 2
76 je short .do_word ; 2 byte variant
77 cmp al, 1
78 je short .do_byte ; 1 bytes variant
79 int3
80
81 ; workers
82%ifdef RT_ARCH_AMD64
83.do_qword:
84 cmp rcx, rdx ; do 8 bytes CMP
85 jmp short .done
86%endif
87
88.do_dword:
89 cmp ecx, edx ; do 4 bytes CMP
90 jmp short .done
91
92.do_word:
93 cmp cx, dx ; do 2 bytes CMP
94 jmp short .done
95
96.do_byte:
97 cmp cl, dl ; do 1 byte CMP
98
99 ; collect flags and return.
100.done:
101 pushf
102 pop MY_RET_REG
103 retn
104ENDPROC EMEmulateCmp
105
106
107;;
108; Emulate AND instruction, CDECL calling conv.
109; EMDECL(uint32_t) EMEmulateAnd(uint32_t *pu32Param1, uint32_t u32Param2, size_t cb);
110;
111; @returns EFLAGS after the operation, only arithmetic flags is valid.
112; @param [esp + 04h] Param 1 - First parameter - pointer to data item.
113; @param [esp + 08h] Param 2 - Second parameter.
114; @param [esp + 0ch] Param 3 - Size of parameters, only 1/2/4 is valid.
115; @uses eax, ecx, edx
116;
117align 16
118BEGINPROC EMEmulateAnd
119%ifdef RT_ARCH_AMD64
120%ifdef RT_OS_WINDOWS
121 mov rax, r8 ; eax = size of parameters
122%else ; !RT_OS_WINDOWS
123 mov rax, rdx ; rax = size of parameters
124 mov rcx, rdi ; rcx = first parameter
125 mov rdx, rsi ; rdx = second parameter
126%endif ; !RT_OS_WINDOWS
127%else ; !RT_ARCH_AMD64
128 mov eax, [esp + 0ch] ; eax = size of parameters
129 mov ecx, [esp + 04h] ; ecx = first parameter
130 mov edx, [esp + 08h] ; edx = second parameter
131%endif
132
133 ; switch on size
134%ifdef RT_ARCH_AMD64
135 cmp al, 8
136 je short .do_qword ; 8 bytes variant
137%endif
138 cmp al, 4
139 je short .do_dword ; 4 bytes variant
140 cmp al, 2
141 je short .do_word ; 2 byte variant
142 cmp al, 1
143 je short .do_byte ; 1 bytes variant
144 int3
145
146 ; workers
147%ifdef RT_ARCH_AMD64
148.do_qword:
149 and [MY_PTR_REG], rdx ; do 8 bytes AND
150 jmp short .done
151%endif
152
153.do_dword:
154 and [MY_PTR_REG], edx ; do 4 bytes AND
155 jmp short .done
156
157.do_word:
158 and [MY_PTR_REG], dx ; do 2 bytes AND
159 jmp short .done
160
161.do_byte:
162 and [MY_PTR_REG], dl ; do 1 byte AND
163
164 ; collect flags and return.
165.done:
166 pushf
167 pop MY_RET_REG
168 retn
169ENDPROC EMEmulateAnd
170
171
172;;
173; Emulate OR instruction, CDECL calling conv.
174; EMDECL(uint32_t) EMEmulateOr(uint32_t *pu32Param1, uint32_t u32Param2, size_t cb);
175;
176; @returns EFLAGS after the operation, only arithmetic flags is valid.
177; @param [esp + 04h] Param 1 - First parameter - pointer to data item.
178; @param [esp + 08h] Param 2 - Second parameter.
179; @param [esp + 0ch] Param 3 - Size of parameters, only 1/2/4 is valid.
180; @uses eax, ecx, edx
181;
182align 16
183BEGINPROC EMEmulateOr
184%ifdef RT_ARCH_AMD64
185%ifdef RT_OS_WINDOWS
186 mov rax, r8 ; eax = size of parameters
187%else ; !RT_OS_WINDOWS
188 mov rax, rdx ; rax = size of parameters
189 mov rcx, rdi ; rcx = first parameter
190 mov rdx, rsi ; rdx = second parameter
191%endif ; !RT_OS_WINDOWS
192%else ; !RT_ARCH_AMD64
193 mov eax, [esp + 0ch] ; eax = size of parameters
194 mov ecx, [esp + 04h] ; ecx = first parameter
195 mov edx, [esp + 08h] ; edx = second parameter
196%endif
197
198 ; switch on size
199%ifdef RT_ARCH_AMD64
200 cmp al, 8
201 je short .do_qword ; 8 bytes variant
202%endif
203 cmp al, 4
204 je short .do_dword ; 4 bytes variant
205 cmp al, 2
206 je short .do_word ; 2 byte variant
207 cmp al, 1
208 je short .do_byte ; 1 bytes variant
209 int3
210
211 ; workers
212%ifdef RT_ARCH_AMD64
213.do_qword:
214 or [MY_PTR_REG], rdx ; do 8 bytes OR
215 jmp short .done
216%endif
217
218.do_dword:
219 or [MY_PTR_REG], edx ; do 4 bytes OR
220 jmp short .done
221
222.do_word:
223 or [MY_PTR_REG], dx ; do 2 bytes OR
224 jmp short .done
225
226.do_byte:
227 or [MY_PTR_REG], dl ; do 1 byte OR
228
229 ; collect flags and return.
230.done:
231 pushf
232 pop MY_RET_REG
233 retn
234ENDPROC EMEmulateOr
235
236;;
237; Emulate XOR instruction, CDECL calling conv.
238; EMDECL(uint32_t) EMEmulateXor(uint32_t *pu32Param1, uint32_t u32Param2, size_t cb);
239;
240; @returns EFLAGS after the operation, only arithmetic flags is valid.
241; @param [esp + 04h] Param 1 - First parameter - pointer to data item.
242; @param [esp + 08h] Param 2 - Second parameter.
243; @param [esp + 0ch] Param 3 - Size of parameters, only 1/2/4 is valid.
244; @uses eax, ecx, edx
245;
246align 16
247BEGINPROC EMEmulateXor
248%ifdef RT_ARCH_AMD64
249%ifdef RT_OS_WINDOWS
250 mov rax, r8 ; eax = size of parameters
251%else ; !RT_OS_WINDOWS
252 mov rax, rdx ; rax = size of parameters
253 mov rcx, rdi ; rcx = first parameter
254 mov rdx, rsi ; rdx = second parameter
255%endif ; !RT_OS_WINDOWS
256%else ; !RT_ARCH_AMD64
257 mov eax, [esp + 0ch] ; eax = size of parameters
258 mov ecx, [esp + 04h] ; ecx = first parameter
259 mov edx, [esp + 08h] ; edx = second parameter
260%endif
261
262 ; switch on size
263%ifdef RT_ARCH_AMD64
264 cmp al, 8
265 je short .do_qword ; 8 bytes variant
266%endif
267 cmp al, 4
268 je short .do_dword ; 4 bytes variant
269 cmp al, 2
270 je short .do_word ; 2 byte variant
271 cmp al, 1
272 je short .do_byte ; 1 bytes variant
273 int3
274
275 ; workers
276%ifdef RT_ARCH_AMD64
277.do_qword:
278 xor [MY_PTR_REG], rdx ; do 8 bytes XOR
279 jmp short .done
280%endif
281
282.do_dword:
283 xor [MY_PTR_REG], edx ; do 4 bytes XOR
284 jmp short .done
285
286.do_word:
287 xor [MY_PTR_REG], dx ; do 2 bytes XOR
288 jmp short .done
289
290.do_byte:
291 xor [MY_PTR_REG], dl ; do 1 byte XOR
292
293 ; collect flags and return.
294.done:
295 pushf
296 pop MY_RET_REG
297 retn
298ENDPROC EMEmulateXor
299
300;;
301; Emulate INC instruction, CDECL calling conv.
302; EMDECL(uint32_t) EMEmulateInc(uint32_t *pu32Param1, size_t cb);
303;
304; @returns EFLAGS after the operation, only arithmetic flags are valid.
305; @param [esp + 04h] rdi rcx Param 1 - First parameter - pointer to data item.
306; @param [esp + 08h] rsi rdx Param 2 - Size of parameters, only 1/2/4 is valid.
307; @uses eax, ecx, edx
308;
309align 16
310BEGINPROC EMEmulateInc
311%ifdef RT_ARCH_AMD64
312%ifdef RT_OS_WINDOWS
313 mov rax, rdx ; eax = size of parameters
314%else ; !RT_OS_WINDOWS
315 mov rax, rsi ; eax = size of parameters
316 mov rcx, rdi ; rcx = first parameter
317%endif ; !RT_OS_WINDOWS
318%else ; !RT_ARCH_AMD64
319 mov eax, [esp + 08h] ; eax = size of parameters
320 mov ecx, [esp + 04h] ; ecx = first parameter
321%endif
322
323 ; switch on size
324%ifdef RT_ARCH_AMD64
325 cmp al, 8
326 je short .do_qword ; 8 bytes variant
327%endif
328 cmp al, 4
329 je short .do_dword ; 4 bytes variant
330 cmp al, 2
331 je short .do_word ; 2 byte variant
332 cmp al, 1
333 je short .do_byte ; 1 bytes variant
334 int3
335
336 ; workers
337%ifdef RT_ARCH_AMD64
338.do_qword:
339 inc qword [MY_PTR_REG] ; do 8 bytes INC
340 jmp short .done
341%endif
342
343.do_dword:
344 inc dword [MY_PTR_REG] ; do 4 bytes INC
345 jmp short .done
346
347.do_word:
348 inc word [MY_PTR_REG] ; do 2 bytes INC
349 jmp short .done
350
351.do_byte:
352 inc byte [MY_PTR_REG] ; do 1 byte INC
353 jmp short .done
354
355 ; collect flags and return.
356.done:
357 pushf
358 pop MY_RET_REG
359 retn
360ENDPROC EMEmulateInc
361
362
363;;
364; Emulate DEC instruction, CDECL calling conv.
365; EMDECL(uint32_t) EMEmulateDec(uint32_t *pu32Param1, size_t cb);
366;
367; @returns EFLAGS after the operation, only arithmetic flags are valid.
368; @param [esp + 04h] Param 1 - First parameter - pointer to data item.
369; @param [esp + 08h] Param 2 - Size of parameters, only 1/2/4 is valid.
370; @uses eax, ecx, edx
371;
372align 16
373BEGINPROC EMEmulateDec
374%ifdef RT_ARCH_AMD64
375%ifdef RT_OS_WINDOWS
376 mov rax, rdx ; eax = size of parameters
377%else ; !RT_OS_WINDOWS
378 mov rax, rsi ; eax = size of parameters
379 mov rcx, rdi ; rcx = first parameter
380%endif ; !RT_OS_WINDOWS
381%else ; !RT_ARCH_AMD64
382 mov eax, [esp + 08h] ; eax = size of parameters
383 mov ecx, [esp + 04h] ; ecx = first parameter
384%endif
385
386 ; switch on size
387%ifdef RT_ARCH_AMD64
388 cmp al, 8
389 je short .do_qword ; 8 bytes variant
390%endif
391 cmp al, 4
392 je short .do_dword ; 4 bytes variant
393 cmp al, 2
394 je short .do_word ; 2 byte variant
395 cmp al, 1
396 je short .do_byte ; 1 bytes variant
397 int3
398
399 ; workers
400%ifdef RT_ARCH_AMD64
401.do_qword:
402 dec qword [MY_PTR_REG] ; do 8 bytes DEC
403 jmp short .done
404%endif
405
406.do_dword:
407 dec dword [MY_PTR_REG] ; do 4 bytes DEC
408 jmp short .done
409
410.do_word:
411 dec word [MY_PTR_REG] ; do 2 bytes DEC
412 jmp short .done
413
414.do_byte:
415 dec byte [MY_PTR_REG] ; do 1 byte DEC
416 jmp short .done
417
418 ; collect flags and return.
419.done:
420 pushf
421 pop MY_RET_REG
422 retn
423ENDPROC EMEmulateDec
424
425;;
426; Emulate ADD instruction, CDECL calling conv.
427; EMDECL(uint32_t) EMEmulateAdd(uint32_t *pu32Param1, uint32_t u32Param2, size_t cb);
428;
429; @returns EFLAGS after the operation, only arithmetic flags is valid.
430; @param [esp + 04h] Param 1 - First parameter - pointer to data item.
431; @param [esp + 08h] Param 2 - Second parameter.
432; @param [esp + 0ch] Param 3 - Size of parameters, only 1/2/4 is valid.
433; @uses eax, ecx, edx
434;
435align 16
436BEGINPROC EMEmulateAdd
437%ifdef RT_ARCH_AMD64
438%ifdef RT_OS_WINDOWS
439 mov rax, r8 ; eax = size of parameters
440%else ; !RT_OS_WINDOWS
441 mov rax, rdx ; rax = size of parameters
442 mov rcx, rdi ; rcx = first parameter
443 mov rdx, rsi ; rdx = second parameter
444%endif ; !RT_OS_WINDOWS
445%else ; !RT_ARCH_AMD64
446 mov eax, [esp + 0ch] ; eax = size of parameters
447 mov ecx, [esp + 04h] ; ecx = first parameter
448 mov edx, [esp + 08h] ; edx = second parameter
449%endif
450
451 ; switch on size
452%ifdef RT_ARCH_AMD64
453 cmp al, 8
454 je short .do_qword ; 8 bytes variant
455%endif
456 cmp al, 4
457 je short .do_dword ; 4 bytes variant
458 cmp al, 2
459 je short .do_word ; 2 byte variant
460 cmp al, 1
461 je short .do_byte ; 1 bytes variant
462 int3
463
464 ; workers
465%ifdef RT_ARCH_AMD64
466.do_qword:
467 add [MY_PTR_REG], rdx ; do 8 bytes ADD
468 jmp short .done
469%endif
470
471.do_dword:
472 add [MY_PTR_REG], edx ; do 4 bytes ADD
473 jmp short .done
474
475.do_word:
476 add [MY_PTR_REG], dx ; do 2 bytes ADD
477 jmp short .done
478
479.do_byte:
480 add [MY_PTR_REG], dl ; do 1 byte ADD
481
482 ; collect flags and return.
483.done:
484 pushf
485 pop MY_RET_REG
486 retn
487ENDPROC EMEmulateAdd
488
489;;
490; Emulate ADC instruction, CDECL calling conv.
491; EMDECL(uint32_t) EMEmulateAdcWithCarrySet(uint32_t *pu32Param1, uint32_t u32Param2, size_t cb);
492;
493; @returns EFLAGS after the operation, only arithmetic flags is valid.
494; @param [esp + 04h] Param 1 - First parameter - pointer to data item.
495; @param [esp + 08h] Param 2 - Second parameter.
496; @param [esp + 0ch] Param 3 - Size of parameters, only 1/2/4 is valid.
497; @uses eax, ecx, edx
498;
499align 16
500BEGINPROC EMEmulateAdcWithCarrySet
501%ifdef RT_ARCH_AMD64
502%ifdef RT_OS_WINDOWS
503 mov rax, r8 ; eax = size of parameters
504%else ; !RT_OS_WINDOWS
505 mov rax, rdx ; rax = size of parameters
506 mov rcx, rdi ; rcx = first parameter
507 mov rdx, rsi ; rdx = second parameter
508%endif ; !RT_OS_WINDOWS
509%else ; !RT_ARCH_AMD64
510 mov eax, [esp + 0ch] ; eax = size of parameters
511 mov ecx, [esp + 04h] ; ecx = first parameter
512 mov edx, [esp + 08h] ; edx = second parameter
513%endif
514
515 ; switch on size
516%ifdef RT_ARCH_AMD64
517 cmp al, 8
518 je short .do_qword ; 8 bytes variant
519%endif
520 cmp al, 4
521 je short .do_dword ; 4 bytes variant
522 cmp al, 2
523 je short .do_word ; 2 byte variant
524 cmp al, 1
525 je short .do_byte ; 1 bytes variant
526 int3
527
528 ; workers
529%ifdef RT_ARCH_AMD64
530.do_qword:
531 stc ; set carry flag
532 adc [MY_PTR_REG], rdx ; do 8 bytes ADC
533 jmp short .done
534%endif
535
536.do_dword:
537 stc ; set carry flag
538 adc [MY_PTR_REG], edx ; do 4 bytes ADC
539 jmp short .done
540
541.do_word:
542 stc ; set carry flag
543 adc [MY_PTR_REG], dx ; do 2 bytes ADC
544 jmp short .done
545
546.do_byte:
547 stc ; set carry flag
548 adc [MY_PTR_REG], dl ; do 1 byte ADC
549
550 ; collect flags and return.
551.done:
552 pushf
553 pop MY_RET_REG
554 retn
555ENDPROC EMEmulateAdcWithCarrySet
556
557;;
558; Emulate SUB instruction, CDECL calling conv.
559; EMDECL(uint32_t) EMEmulateSub(uint32_t *pu32Param1, uint32_t u32Param2, size_t cb);
560;
561; @returns EFLAGS after the operation, only arithmetic flags is valid.
562; @param [esp + 04h] Param 1 - First parameter - pointer to data item.
563; @param [esp + 08h] Param 2 - Second parameter.
564; @param [esp + 0ch] Param 3 - Size of parameters, only 1/2/4 is valid.
565; @uses eax, ecx, edx
566;
567align 16
568BEGINPROC EMEmulateSub
569%ifdef RT_ARCH_AMD64
570%ifdef RT_OS_WINDOWS
571 mov rax, r8 ; eax = size of parameters
572%else ; !RT_OS_WINDOWS
573 mov rax, rdx ; rax = size of parameters
574 mov rcx, rdi ; rcx = first parameter
575 mov rdx, rsi ; rdx = second parameter
576%endif ; !RT_OS_WINDOWS
577%else ; !RT_ARCH_AMD64
578 mov eax, [esp + 0ch] ; eax = size of parameters
579 mov ecx, [esp + 04h] ; ecx = first parameter
580 mov edx, [esp + 08h] ; edx = second parameter
581%endif
582
583 ; switch on size
584%ifdef RT_ARCH_AMD64
585 cmp al, 8
586 je short .do_qword ; 8 bytes variant
587%endif
588 cmp al, 4
589 je short .do_dword ; 4 bytes variant
590 cmp al, 2
591 je short .do_word ; 2 byte variant
592 cmp al, 1
593 je short .do_byte ; 1 bytes variant
594 int3
595
596 ; workers
597%ifdef RT_ARCH_AMD64
598.do_qword:
599 sub [MY_PTR_REG], rdx ; do 8 bytes SUB
600 jmp short .done
601%endif
602
603.do_dword:
604 sub [MY_PTR_REG], edx ; do 4 bytes SUB
605 jmp short .done
606
607.do_word:
608 sub [MY_PTR_REG], dx ; do 2 bytes SUB
609 jmp short .done
610
611.do_byte:
612 sub [MY_PTR_REG], dl ; do 1 byte SUB
613
614 ; collect flags and return.
615.done:
616 pushf
617 pop MY_RET_REG
618 retn
619ENDPROC EMEmulateSub
620
621
622;;
623; Emulate BTR instruction, CDECL calling conv.
624; EMDECL(uint32_t) EMEmulateBtr(uint32_t *pu32Param1, uint32_t u32Param2);
625;
626; @returns EFLAGS after the operation, only arithmetic flags is valid.
627; @param [esp + 04h] Param 1 - First parameter - pointer to data item.
628; @param [esp + 08h] Param 2 - Second parameter.
629; @uses eax, ecx, edx
630;
631align 16
632BEGINPROC EMEmulateBtr
633%ifdef RT_ARCH_AMD64
634%ifndef RT_OS_WINDOWS
635 mov rcx, rdi ; rcx = first parameter
636 mov rdx, rsi ; rdx = second parameter
637%endif ; !RT_OS_WINDOWS
638%else ; !RT_ARCH_AMD64
639 mov ecx, [esp + 04h] ; ecx = first parameter
640 mov edx, [esp + 08h] ; edx = second parameter
641%endif
642
643 and edx, 7
644 btr [MY_PTR_REG], edx
645
646 ; collect flags and return.
647 pushf
648 pop MY_RET_REG
649 retn
650ENDPROC EMEmulateBtr
651
652;;
653; Emulate BTC instruction, CDECL calling conv.
654; EMDECL(uint32_t) EMEmulateBtc(uint32_t *pu32Param1, uint32_t u32Param2);
655;
656; @returns EFLAGS after the operation, only arithmetic flags is valid.
657; @param [esp + 04h] Param 1 - First parameter - pointer to data item.
658; @param [esp + 08h] Param 2 - Second parameter.
659; @uses eax, ecx, edx
660;
661align 16
662BEGINPROC EMEmulateBtc
663%ifdef RT_ARCH_AMD64
664%ifndef RT_OS_WINDOWS
665 mov rcx, rdi ; rcx = first parameter
666 mov rdx, rsi ; rdx = second parameter
667%endif ; !RT_OS_WINDOWS
668%else ; !RT_ARCH_AMD64
669 mov ecx, [esp + 04h] ; ecx = first parameter
670 mov edx, [esp + 08h] ; edx = second parameter
671%endif
672
673 and edx, 7
674 btc [MY_PTR_REG], edx
675
676 ; collect flags and return.
677 pushf
678 pop MY_RET_REG
679 retn
680ENDPROC EMEmulateBtc
681
682;;
683; Emulate BTS instruction, CDECL calling conv.
684; EMDECL(uint32_t) EMEmulateBts(uint32_t *pu32Param1, uint32_t u32Param2);
685;
686; @returns EFLAGS after the operation, only arithmetic flags is valid.
687; @param [esp + 04h] Param 1 - First parameter - pointer to data item.
688; @param [esp + 08h] Param 2 - Second parameter.
689; @uses eax, ecx, edx
690;
691align 16
692BEGINPROC EMEmulateBts
693%ifdef RT_ARCH_AMD64
694%ifndef RT_OS_WINDOWS
695 mov rcx, rdi ; rcx = first parameter
696 mov rdx, rsi ; rdx = second parameter
697%endif ; !RT_OS_WINDOWS
698%else ; !RT_ARCH_AMD64
699 mov ecx, [esp + 04h] ; ecx = first parameter
700 mov edx, [esp + 08h] ; edx = second parameter
701%endif
702
703 and edx, 7
704 bts [MY_PTR_REG], edx
705
706 ; collect flags and return.
707 pushf
708 pop MY_RET_REG
709 retn
710ENDPROC EMEmulateBts
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