ReactOS 0.4.15-dev-8235-gcd88a97
ExInterlocked.c
Go to the documentation of this file.
1/*
2 * PROJECT: ReactOS kernel-mode tests
3 * LICENSE: GPLv2+ - See COPYING in the top level directory
4 * PURPOSE: Kernel-Mode Test Suite Interlocked function test
5 * PROGRAMMER: Thomas Faber <thomas.faber@reactos.org>
6 */
7
8#include <stddef.h>
9
10/* missing prototypes >:| */
11__declspec(dllimport) long __fastcall InterlockedCompareExchange(volatile long *, long, long);
13__declspec(dllimport) __int64 __fastcall ExfInterlockedCompareExchange64(volatile __int64 *, __int64 *, __int64 *);
14__declspec(dllimport) long __fastcall InterlockedExchange(volatile long *, long);
15__declspec(dllimport) unsigned long __stdcall ExInterlockedExchangeUlong(unsigned long *, unsigned long, void *);
16__declspec(dllimport) long __fastcall InterlockedExchangeAdd(volatile long *, long);
17#ifdef _X86_
18__declspec(dllimport) unsigned long __stdcall ExInterlockedAddUlong(unsigned long *, unsigned long, unsigned long *);
19#endif
20__declspec(dllimport) unsigned long __stdcall Exi386InterlockedExchangeUlong(unsigned long *, unsigned long);
21__declspec(dllimport) long __fastcall InterlockedIncrement(long *);
22__declspec(dllimport) long __fastcall InterlockedDecrement(long *);
23__declspec(dllimport) int __stdcall ExInterlockedIncrementLong(long *, void *);
24__declspec(dllimport) int __stdcall ExInterlockedDecrementLong(long *, void *);
25__declspec(dllimport) int __stdcall Exi386InterlockedIncrementLong(long *);
26__declspec(dllimport) int __stdcall Exi386InterlockedDecrementLong(long *);
27
28#include <kmt_test.h>
29
30/* TODO: There are quite some changes needed for other architectures!
31 ExInterlockedAddLargeInteger, ExInterlockedAddUlong are the only two
32 functions actually exported by my win7/x64 kernel! */
33
34/* TODO: stress-testing */
35
36static KSPIN_LOCK SpinLock;
37
38#ifdef _M_IX86
39typedef struct
40{
41 unsigned long esi, edi, ebx, ebp, esp;
42} PROCESSOR_STATE;
43#elif defined(_M_AMD64)
44typedef struct
45{
46 unsigned long long rsi, rdi, rbx, rbp, rsp, r12, r13, r14, r15;
47} PROCESSOR_STATE;
48#else
49// dummy
50typedef int PROCESSOR_STATE;
51#endif
52
53/* TODO: these need to be rewritten in proper assembly to account for registers
54 * saved by the caller */
55#if defined(_MSC_VER) && defined(_M_IX86)
56#define SaveState(State) do \
57{ \
58 __asm lea ecx, [State] \
59 __asm mov [ecx], esi \
60 __asm mov [ecx+4], edi \
61 __asm mov [ecx+8], ebx \
62 __asm mov [ecx+12], ebp \
63 __asm mov [ecx+16], esp \
64} while (0)
65
66#define CheckState(OldState, NewState) do \
67{ \
68 /* TODO: MSVC uses esi and saves it before, so this is okay */ \
69 /*ok_eq_hex((OldState)->esi, (NewState)->esi);*/ \
70 ok_eq_hex((OldState)->edi, (NewState)->edi); \
71 ok_eq_hex((OldState)->ebx, (NewState)->ebx); \
72 ok_eq_hex((OldState)->ebp, (NewState)->ebp); \
73 ok_eq_hex((OldState)->esp, (NewState)->esp); \
74} while (0)
75
76#elif defined(__GNUC__) && defined(_M_IX86)
77#define SaveState(State) \
78 asm volatile( \
79 "movl\t%%esi, (%%ecx)\n\t" \
80 "movl\t%%edi, 4(%%ecx)\n\t" \
81 "movl\t%%ebx, 8(%%ecx)\n\t" \
82 "movl\t%%ebp, 12(%%ecx)\n\t" \
83 "movl\t%%esp, 16(%%ecx)" \
84 : : "c" (&State) : "memory" \
85 );
86
87#define CheckState(OldState, NewState) do \
88{ \
89 /* TODO: GCC 4.7 uses esi and saves it before, so this is okay */ \
90 /*ok_eq_hex((OldState)->esi, (NewState)->esi);*/ \
91 ok_eq_hex((OldState)->edi, (NewState)->edi); \
92 /* TODO: GCC 4.4 uses ebx and saves it before, so this is okay */ \
93 /*ok_eq_hex((OldState)->ebx, (NewState)->ebx);*/ \
94 ok_eq_hex((OldState)->ebp, (NewState)->ebp); \
95 ok_eq_hex((OldState)->esp, (NewState)->esp); \
96} while (0)
97#elif defined(__GNUC__) && defined(_M_AMD64)
98#define SaveState(State) \
99 asm volatile( \
100 "mov\t%%rsi, (%%rcx)\n\t" \
101 "mov\t%%rdi, 8(%%rcx)\n\t" \
102 "mov\t%%rbx, 16(%%rcx)\n\t" \
103 "mov\t%%rbp, 24(%%rcx)\n\t" \
104 "mov\t%%rsp, 32(%%rcx)\n\t" \
105 "mov\t%%r12, 40(%%rcx)\n\t" \
106 "mov\t%%r13, 48(%%rcx)\n\t" \
107 "mov\t%%r14, 56(%%rcx)\n\t" \
108 "mov\t%%r15, 64(%%rcx)" \
109 : : "c" (&State) : "memory" \
110 );
111
112#define CheckState(OldState, NewState) do \
113{ \
114 ok_eq_hex((OldState)->rsi, (NewState)->rsi); \
115 ok_eq_hex((OldState)->rdi, (NewState)->rdi); \
116 ok_eq_hex((OldState)->rbx, (NewState)->rbx); \
117 ok_eq_hex((OldState)->rbp, (NewState)->rbp); \
118 ok_eq_hex((OldState)->rsp, (NewState)->rsp); \
119 ok_eq_hex((OldState)->r12, (NewState)->r12); \
120 ok_eq_hex((OldState)->r13, (NewState)->r13); \
121 ok_eq_hex((OldState)->r14, (NewState)->r14); \
122 ok_eq_hex((OldState)->r15, (NewState)->r15); \
123} while (0)
124#else
125#define SaveState(State)
126#define CheckState(OldState, NewState) do \
127{ \
128 (void)OldState; \
129 (void)NewState; \
130} while (0)
131#endif
132
133static
135Large(
137{
138 LARGE_INTEGER Ret;
139 Ret.QuadPart = Value;
140 return Ret;
141}
142
143#define CheckInterlockedCmpXchg(Function, Type, Print, Val, Cmp, Xchg, \
144 ExpectedValue, ExpectedRet) do \
145{ \
146 Type Ret##Type = 0; \
147 Type Value##Type = Val; \
148 Status = STATUS_SUCCESS; \
149 _SEH2_TRY { \
150 SaveState(OldState); \
151 Ret##Type = Function(&Value##Type, Xchg, Cmp); \
152 SaveState(NewState); \
153 CheckState(&OldState, &NewState); \
154 } _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER) { \
155 Status = _SEH2_GetExceptionCode(); \
156 } _SEH2_END; \
157 ok_eq_hex(Status, STATUS_SUCCESS); \
158 ok_eq_print(Ret##Type, ExpectedRet, Print); \
159 ok_eq_print(Value##Type, ExpectedValue, Print); \
160} while (0)
161
162#define CheckInterlockedCmpXchgI(Function, Type, Print, Val, Cmp, Xchg, \
163 ExpectedValue, ExpectedRet, ...) do \
164{ \
165 Type Ret##Type = 0; \
166 Type Value##Type = Val; \
167 Type Compare##Type = Cmp; \
168 Type Exchange##Type = Xchg; \
169 Status = STATUS_SUCCESS; \
170 _SEH2_TRY { \
171 SaveState(OldState); \
172 Ret##Type = Function(&Value##Type, &Exchange##Type, \
173 &Compare##Type, ##__VA_ARGS__); \
174 SaveState(NewState); \
175 CheckState(&OldState, &NewState); \
176 } _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER) { \
177 Status = _SEH2_GetExceptionCode(); \
178 } _SEH2_END; \
179 ok_eq_hex(Status, STATUS_SUCCESS); \
180 ok_eq_print(Ret##Type, ExpectedRet, Print); \
181 ok_eq_print(Value##Type, ExpectedValue, Print); \
182 ok_eq_print(Exchange##Type, Xchg, Print); \
183 ok_eq_print(Compare##Type, Cmp, Print); \
184} while(0)
185
186#define CheckInterlockedOp(Function, Type, Print, Val, Op, \
187 ExpectedValue, ExpectedRet, ...) do \
188{ \
189 Type Ret##Type = 0; \
190 Type Value##Type = Val; \
191 Status = STATUS_SUCCESS; \
192 _SEH2_TRY { \
193 SaveState(OldState); \
194 Ret##Type = Function(&Value##Type, Op, ##__VA_ARGS__); \
195 SaveState(NewState); \
196 CheckState(&OldState, &NewState); \
197 } _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER) { \
198 Status = _SEH2_GetExceptionCode(); \
199 } _SEH2_END; \
200 ok_eq_hex(Status, STATUS_SUCCESS); \
201 ok_eq_print(Ret##Type, ExpectedRet, Print); \
202 ok_eq_print(Value##Type, ExpectedValue, Print); \
203} while (0)
204
205#define CheckInterlockedOpNoArg(Function, Type, Print, Val, \
206 ExpectedValue, ExpectedRet, ...) do \
207{ \
208 Type Ret##Type = 0; \
209 Type Value##Type = Val; \
210 Status = STATUS_SUCCESS; \
211 _SEH2_TRY { \
212 SaveState(OldState); \
213 Ret##Type = Function(&Value##Type, ##__VA_ARGS__); \
214 SaveState(NewState); \
215 CheckState(&OldState, &NewState); \
216 } _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER) { \
217 Status = _SEH2_GetExceptionCode(); \
218 } _SEH2_END; \
219 ok_eq_hex(Status, STATUS_SUCCESS); \
220 ok_eq_print(Ret##Type, ExpectedRet, Print); \
221 ok_eq_print(Value##Type, ExpectedValue, Print); \
222} while (0)
223
224#define CheckInterlockedOpLarge(Function, Type, Print, Val, Op, \
225 ExpectedValue, ExpectedRet, ...) do \
226{ \
227 Type Ret##Type = Large(0); \
228 Type Value##Type = Val; \
229 Status = STATUS_SUCCESS; \
230 _SEH2_TRY { \
231 SaveState(OldState); \
232 Ret##Type = Function(&Value##Type, Op, ##__VA_ARGS__); \
233 SaveState(NewState); \
234 CheckState(&OldState, &NewState); \
235 } _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER) { \
236 Status = _SEH2_GetExceptionCode(); \
237 } _SEH2_END; \
238 ok_eq_hex(Status, STATUS_SUCCESS); \
239 ok_eq_print(Ret##Type.QuadPart, ExpectedRet, Print); \
240 ok_eq_print(Value##Type.QuadPart, ExpectedValue, Print); \
241} while (0)
242
243#define CheckInterlockedOpLargeNoRet(Function, Type, Print, Val, Op, \
244 ExpectedValue) do \
245{ \
246 Type Value##Type = Val; \
247 Status = STATUS_SUCCESS; \
248 _SEH2_TRY { \
249 SaveState(OldState); \
250 Function(&Value##Type, Op); \
251 SaveState(NewState); \
252 CheckState(&OldState, &NewState); \
253 } _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER) { \
254 Status = _SEH2_GetExceptionCode(); \
255 } _SEH2_END; \
256 ok_eq_hex(Status, STATUS_SUCCESS); \
257 ok_eq_print(Value##Type.QuadPart, ExpectedValue, Print); \
258} while (0)
259
260static
261VOID
263{
265 PKSPIN_LOCK pSpinLock = &SpinLock;
266 PROCESSOR_STATE OldState, NewState;
267
268 /* on x86, most of these are supported intrinsically and don't need a spinlock! */
269#if defined _M_IX86 || defined _M_AMD64
270 pSpinLock = NULL;
271#endif
272
273 /* CompareExchange */
274 /* macro version */
277 /* these only exist as macros on x86 */
280 CheckInterlockedCmpXchg(InterlockedCompareExchangeRelease, LONG, "%ld", 27, 123, 38, 27L, 27L);
282 /* exported function */
283#undef InterlockedCompareExchange
284#ifdef _M_IX86
287#endif
288 /* only exists as a macro */
291 /* macro version */
292 CheckInterlockedCmpXchgI(ExInterlockedCompareExchange64, LONGLONG, "%I64d", 17, 4LL, 20LL, 17LL, 17LL, pSpinLock);
293 CheckInterlockedCmpXchgI(ExInterlockedCompareExchange64, LONGLONG, "%I64d", 17, 17LL, 21LL, 21LL, 17LL, pSpinLock);
294#ifdef _M_IX86
295 /* exported function */
296 CheckInterlockedCmpXchgI((ExInterlockedCompareExchange64), LONGLONG, "%I64d", 17, 4LL, 20LL, 17LL, 17LL, pSpinLock);
297 CheckInterlockedCmpXchgI((ExInterlockedCompareExchange64), LONGLONG, "%I64d", 17, 17LL, 21LL, 21LL, 17LL, pSpinLock);
298 /* fastcall version */
299 CheckInterlockedCmpXchgI(ExfInterlockedCompareExchange64, LONGLONG, "%I64d", 17, 4LL, 20LL, 17LL, 17LL);
300 CheckInterlockedCmpXchgI(ExfInterlockedCompareExchange64, LONGLONG, "%I64d", 17, 17LL, 21LL, 21LL, 17LL);
301#endif
302
303 /* Exchange */
304 CheckInterlockedOp(InterlockedExchange, LONG, "%ld", 5, 8, 8L, 5L);
306#undef InterlockedExchange
307#ifdef _M_IX86
308 CheckInterlockedOp(InterlockedExchange, LONG, "%ld", 5, 8, 8L, 5L);
309 CheckInterlockedOp(ExInterlockedExchangeUlong, ULONG, "%lu", 212, 121, 121LU, 212LU, pSpinLock);
310 CheckInterlockedOp((ExInterlockedExchangeUlong), ULONG, "%lu", 212, 121, 121LU, 212LU, pSpinLock);
311 CheckInterlockedOp(Exi386InterlockedExchangeUlong, ULONG, "%lu", 212, 121, 121LU, 212LU);
312 CheckInterlockedOp(Exfi386InterlockedExchangeUlong, ULONG, "%lu", 212, 121, 121LU, 212LU);
313#endif
314
315 /* ExchangeAdd */
316 /* TODO: ExInterlockedExchangeAddLargeInteger? */
317 CheckInterlockedOp(InterlockedExchangeAdd, LONG, "%ld", 312, 7, 319L, 312L);
318#undef InterlockedExchangeAdd
319#ifdef _M_IX86
320 CheckInterlockedOp(InterlockedExchangeAdd, LONG, "%ld", 312, 7, 319L, 312L);
321#endif
322
323 /* Add */
324 /* these DO need a valid spinlock even on x86 */
325 CheckInterlockedOpLarge(ExInterlockedAddLargeInteger, LARGE_INTEGER, "%I64d", Large(23), Large(7), 30LL, 23LL, &SpinLock);
327 CheckInterlockedOp(ExInterlockedAddUlong, ULONG, "%lu", 239, 44, 283LU, 239LU, &SpinLock);
328#undef ExInterlockedAddUlong
329 CheckInterlockedOp(ExInterlockedAddUlong, ULONG, "%lu", 239, 44, 283LU, 239LU, &SpinLock);
330
331 /* Increment */
332 CheckInterlockedOpNoArg(InterlockedIncrement, LONG, "%ld", 2341L, 2342L, 2342L);
334 CheckInterlockedOpNoArg(InterlockedIncrementAcquire, LONG, "%ld", 2341L, 2342L, 2342L);
335 CheckInterlockedOpNoArg(InterlockedIncrementRelease, LONG, "%ld", 2341L, 2342L, 2342L);
336#undef InterlockedIncrement
337#ifdef _M_IX86
338 CheckInterlockedOpNoArg(InterlockedIncrement, LONG, "%ld", 2341L, 2342L, 2342L);
348 CheckInterlockedOpNoArg(Exi386InterlockedIncrementLong, LONG, "%ld", -2L, -1L, (LONG)ResultNegative);
349 CheckInterlockedOpNoArg(Exi386InterlockedIncrementLong, LONG, "%ld", -1L, 0L, (LONG)ResultZero);
350 CheckInterlockedOpNoArg(Exi386InterlockedIncrementLong, LONG, "%ld", 0L, 1L, (LONG)ResultPositive);
351 CheckInterlockedOpNoArg(Exi386InterlockedIncrementLong, LONG, "%ld", (LONG)MAXLONG, (LONG)MINLONG, (LONG)ResultNegative);
352#endif
353
354 /* Decrement */
355 CheckInterlockedOpNoArg(InterlockedDecrement, LONG, "%ld", 1745L, 1744L, 1744L);
357 CheckInterlockedOpNoArg(InterlockedDecrementAcquire, LONG, "%ld", 1745L, 1744L, 1744L);
358 CheckInterlockedOpNoArg(InterlockedDecrementRelease, LONG, "%ld", 1745L, 1744L, 1744L);
359#undef InterlockedDecrement
360#ifdef _M_IX86
361 CheckInterlockedOpNoArg(InterlockedDecrement, LONG, "%ld", 1745L, 1744L, 1744L);
371 CheckInterlockedOpNoArg(Exi386InterlockedDecrementLong, LONG, "%ld", (LONG)MINLONG, (LONG)MAXLONG, (LONG)ResultPositive);
372 CheckInterlockedOpNoArg(Exi386InterlockedDecrementLong, LONG, "%ld", 0L, -1L, (LONG)ResultNegative);
373 CheckInterlockedOpNoArg(Exi386InterlockedDecrementLong, LONG, "%ld", 1L, 0L, (LONG)ResultZero);
374 CheckInterlockedOpNoArg(Exi386InterlockedDecrementLong, LONG, "%ld", 2L, 1L, (LONG)ResultPositive);
375#endif
376
377 /* And, Or, Xor */
378 CheckInterlockedOp(InterlockedAnd, LONG, "0x%lx", 0x1234L, 0x1111L, 0x1010L, 0x1234L);
379 CheckInterlockedOp(InterlockedOr, LONG, "0x%lx", 0x1234L, 0x1111L, 0x1335L, 0x1234L);
380 CheckInterlockedOp(InterlockedXor, LONG, "0x%lx", 0x1234L, 0x1111L, 0x0325L, 0x1234L);
381#ifdef _WIN64
382 CheckInterlockedOp(InterlockedXor64, LONGLONG, "0x%I64x", 0x200001234LL, 0x100001111LL, 0x300000325LL, 0x200001234LL);
383#endif
384}
385
386START_TEST(ExInterlocked)
387{
388 KIRQL Irql;
390
391 /* functional testing */
396}
#define CheckInterlockedOp(Function, Type, Print, Val, Op, ExpectedValue, ExpectedRet,...)
#define CheckInterlockedOpLarge(Function, Type, Print, Val, Op, ExpectedValue, ExpectedRet,...)
__declspec(dllimport)
Definition: ExInterlocked.c:11
static VOID TestInterlockedFunctional(VOID)
#define CheckInterlockedOpNoArg(Function, Type, Print, Val, ExpectedValue, ExpectedRet,...)
#define CheckInterlockedCmpXchg(Function, Type, Print, Val, Cmp, Xchg, ExpectedValue, ExpectedRet)
#define CheckInterlockedOpLargeNoRet(Function, Type, Print, Val, Op, ExpectedValue)
#define CheckInterlockedCmpXchgI(Function, Type, Print, Val, Cmp, Xchg, ExpectedValue, ExpectedRet,...)
#define InterlockedIncrement
Definition: armddk.h:53
#define InterlockedExchange
Definition: armddk.h:54
#define InterlockedDecrement
Definition: armddk.h:52
#define START_TEST(x)
Definition: atltest.h:75
LONG NTSTATUS
Definition: precomp.h:26
#define U(x)
Definition: wordpad.c:45
#define __int64
Definition: basetyps.h:16
_Out_ PKIRQL Irql
Definition: csq.h:179
#define NULL
Definition: types.h:112
#define InterlockedExchangePointer(Target, Value)
Definition: dshow.h:45
UCHAR KIRQL
Definition: env_spec_w32.h:591
ULONG KSPIN_LOCK
Definition: env_spec_w32.h:72
#define KeRaiseIrql(irql, oldIrql)
Definition: env_spec_w32.h:597
#define HIGH_LEVEL
Definition: env_spec_w32.h:703
KSPIN_LOCK * PKSPIN_LOCK
Definition: env_spec_w32.h:73
#define KeLowerIrql(oldIrql)
Definition: env_spec_w32.h:602
#define KeInitializeSpinLock(sl)
Definition: env_spec_w32.h:604
Status
Definition: gdiplustypes.h:25
ULONG NTAPI ExInterlockedAddUlong(IN OUT PULONG Addend, IN ULONG Increment, IN OUT PKSPIN_LOCK Lock)
Definition: interlocked.c:88
LARGE_INTEGER NTAPI ExInterlockedAddLargeInteger(IN OUT PLARGE_INTEGER Addend, IN LARGE_INTEGER Increment, IN OUT PKSPIN_LOCK Lock)
Definition: interlocked.c:62
#define InterlockedCompareExchangeAcquire
Definition: interlocked.h:105
#define InterlockedIncrementRelease
Definition: interlocked.h:203
#define InterlockedExchangeAdd
Definition: interlocked.h:181
#define InterlockedOr
Definition: interlocked.h:224
#define InterlockedCompareExchangePointer
Definition: interlocked.h:129
#define InterlockedDecrementAcquire
Definition: interlocked.h:135
#define InterlockedCompareExchange
Definition: interlocked.h:104
#define InterlockedIncrementAcquire
Definition: interlocked.h:202
#define InterlockedXor
Definition: interlocked.h:266
#define InterlockedXor64
Definition: interlocked.h:291
#define InterlockedCompareExchangeRelease
Definition: interlocked.h:106
#define InterlockedDecrementRelease
Definition: interlocked.h:136
#define InterlockedAnd
Definition: interlocked.h:62
#define __fastcall
Definition: sync.c:38
#define L(x)
Definition: ntvdm.h:50
long LONG
Definition: pedump.c:60
ecx edi movl ebx edx edi decl ecx esi eax jecxz decl eax andl ebx
Definition: synth_sse3d.h:83
ecx edi movl ebx edx edi decl ecx esi eax jecxz decl eax andl eax esi movl edx movl TEMP incl eax andl eax ecx incl ebx testl eax jnz xchgl ecx incl TEMP esp ecx subl ebx pushl ecx ecx edx ecx shrl ecx mm0 mm4 mm0 mm4 mm1 mm5 mm1 mm5 mm2 mm6 mm2 mm6 mm3 mm7 mm3 mm7 paddd mm0 paddd mm4 paddd mm0 paddd mm4 paddd mm0 paddd mm4 movq mm1 movq mm5 psrlq mm1 psrlq mm5 paddd mm0 paddd mm4 psrad mm0 psrad mm4 packssdw mm0 packssdw mm4 mm1 punpckldq mm0 pand mm1 pand mm0 por mm1 movq edi esi edx edi decl ecx jnz popl ecx andl ecx jecxz mm0 mm0 mm1 mm1 mm2 mm2 mm3 mm3 paddd mm0 paddd mm0 paddd mm0 movq mm1 psrlq mm1 paddd mm0 psrad mm0 packssdw mm0 movd eax movw edi esi edx edi
Definition: synth_sse3d.h:185
ecx edi movl ebx edx edi decl ecx esi eax jecxz decl eax andl eax esi movl edx movl TEMP incl eax andl eax ecx incl ebx testl eax jnz xchgl ecx incl TEMP esi
Definition: synth_sse3d.h:103
ecx edi movl ebx edx edi decl ecx esi eax jecxz decl eax andl eax esi movl edx movl TEMP incl eax andl eax ecx incl ebx testl eax jnz xchgl ecx incl TEMP esp ecx subl ebx pushl ecx ecx edx ecx shrl ecx mm0 mm4 mm0 mm4 mm1 mm5 mm1 mm5 mm2 mm6 mm2 mm6 mm3 mm7 mm3 mm7 paddd mm0 paddd mm4 paddd mm0 paddd mm4 paddd mm0 paddd mm4 movq mm1 movq mm5 psrlq mm1 psrlq mm5 paddd mm0 paddd mm4 psrad mm0 psrad mm4 packssdw mm0 packssdw mm4 mm1 punpckldq mm0 pand mm1 pand mm0 por mm1 movq edi esi edx edi decl ecx jnz popl ecx andl ecx jecxz mm0 mm0 mm1 mm1 mm2 mm2 mm3 mm3 paddd mm0 paddd mm0 paddd mm0 movq mm1 psrlq mm1 paddd mm0 psrad mm0 packssdw mm0 movd eax movw edi esi edx esi movl ecx mm0 mm4 mm0 mm4 mm1 mm5 mm1 mm5 mm2 mm6 mm2 mm6 mm3 mm7 mm3 mm7 paddd mm0 paddd mm4 paddd mm0 paddd mm4 paddd mm0 paddd mm4 movq mm1 movq mm5 psrlq mm1 psrlq mm5 paddd mm1 paddd mm5 psrad mm1 psrad mm5 packssdw mm1 packssdw mm5 psubd mm0 psubd mm4 psubsw mm0 psubsw mm4 mm1 punpckldq mm0 pand mm1 pand mm0 por mm1 movq edi subl esi addl edx edi decl ecx jnz mm0 mm0 mm1 mm1 mm2 mm2 mm3 mm3 paddd mm0 paddd mm0 paddd mm0 movq mm1 psrlq mm1 paddd mm1 psrad mm1 packssdw mm1 psubd mm0 psubsw mm0 movd eax movw edi emms popl ebx popl esi popl edi mov ebp
Definition: synth_sse3d.h:266
int64_t LONGLONG
Definition: typedefs.h:68
#define __stdcall
Definition: typedefs.h:25
uint32_t ULONG
Definition: typedefs.h:59
uint64_t ULONGLONG
Definition: typedefs.h:67
#define MAXLONG
Definition: umtypes.h:116
#define MINLONG
Definition: umtypes.h:115
LONGLONG QuadPart
Definition: typedefs.h:114
_Must_inspect_result_ _In_ WDFKEY _In_ PCUNICODE_STRING _Out_opt_ PUSHORT _Inout_opt_ PUNICODE_STRING Value
Definition: wdfregistry.h:413
_Must_inspect_result_ _In_opt_ PWDF_OBJECT_ATTRIBUTES _Out_ WDFSPINLOCK * SpinLock
Definition: wdfsync.h:228
#define ExInterlockedAddLargeStatistic(Addend, Increment)
Definition: exfuncs.h:850
#define ExInterlockedExchangeUlong(Target, Value, Lock)
#define ExInterlockedDecrementLong(Addend, Lock)
#define ExInterlockedIncrementLong(Addend, Lock)
#define ExInterlockedCompareExchange64(Destination, Exchange, Comperand, Lock)
Definition: exfuncs.h:880
@ ResultPositive
Definition: exfuncs.h:361
@ ResultZero
Definition: exfuncs.h:360
@ ResultNegative
Definition: exfuncs.h:359