ReactOS 0.4.15-dev-8119-g4fb2fdb
ExInterlocked.c File Reference
#include <stddef.h>
#include <kmt_test.h>
Include dependency graph for ExInterlocked.c:

Go to the source code of this file.

Macros

#define SaveState(State)
 
#define CheckState(OldState, NewState)
 
#define CheckInterlockedCmpXchg(Function, Type, Print, Val, Cmp, Xchg, ExpectedValue, ExpectedRet)
 
#define CheckInterlockedCmpXchgI(Function, Type, Print, Val, Cmp, Xchg, ExpectedValue, ExpectedRet, ...)
 
#define CheckInterlockedOp(Function, Type, Print, Val, Op, ExpectedValue, ExpectedRet, ...)
 
#define CheckInterlockedOpNoArg(Function, Type, Print, Val, ExpectedValue, ExpectedRet, ...)
 
#define CheckInterlockedOpLarge(Function, Type, Print, Val, Op, ExpectedValue, ExpectedRet, ...)
 
#define CheckInterlockedOpLargeNoRet(Function, Type, Print, Val, Op, ExpectedValue)
 

Functions

 __declspec (dllimport)
 
static VOID TestInterlockedFunctional (VOID)
 
 START_TEST (ExInterlocked)
 

Macro Definition Documentation

◆ CheckInterlockedCmpXchg

#define CheckInterlockedCmpXchg (   Function,
  Type,
  Print,
  Val,
  Cmp,
  Xchg,
  ExpectedValue,
  ExpectedRet 
)
Value:
do \
{ \
Type Ret##Type = 0; \
Type Value##Type = Val; \
SaveState(OldState); \
Ret##Type = Function(&Value##Type, Xchg, Cmp); \
SaveState(NewState); \
CheckState(&OldState, &NewState); \
} _SEH2_END; \
ok_eq_hex(Status, STATUS_SUCCESS); \
ok_eq_print(Ret##Type, ExpectedRet, Print); \
ok_eq_print(Value##Type, ExpectedValue, Print); \
} while (0)
Type
Definition: Type.h:7
_In_ CDROM_SCAN_FOR_SPECIAL_INFO _In_ PCDROM_SCAN_FOR_SPECIAL_HANDLER Function
Definition: cdrom.h:1156
#define _SEH2_END
Definition: filesup.c:22
#define _SEH2_TRY
Definition: filesup.c:19
Status
Definition: gdiplustypes.h:25
#define EXCEPTION_EXECUTE_HANDLER
Definition: excpt.h:85
#define _SEH2_GetExceptionCode()
Definition: pseh2_64.h:165
#define _SEH2_EXCEPT(...)
Definition: pseh2_64.h:66
#define STATUS_SUCCESS
Definition: shellext.h:65
_Must_inspect_result_ _In_ WDFKEY _In_ PCUNICODE_STRING _Out_opt_ PUSHORT _Inout_opt_ PUNICODE_STRING Value
Definition: wdfregistry.h:413

Definition at line 143 of file ExInterlocked.c.

◆ CheckInterlockedCmpXchgI

#define CheckInterlockedCmpXchgI (   Function,
  Type,
  Print,
  Val,
  Cmp,
  Xchg,
  ExpectedValue,
  ExpectedRet,
  ... 
)
Value:
do \
{ \
Type Ret##Type = 0; \
Type Value##Type = Val; \
Type Compare##Type = Cmp; \
Type Exchange##Type = Xchg; \
SaveState(OldState); \
Ret##Type = Function(&Value##Type, &Exchange##Type, \
&Compare##Type, ##__VA_ARGS__); \
SaveState(NewState); \
CheckState(&OldState, &NewState); \
} _SEH2_END; \
ok_eq_hex(Status, STATUS_SUCCESS); \
ok_eq_print(Ret##Type, ExpectedRet, Print); \
ok_eq_print(Value##Type, ExpectedValue, Print); \
ok_eq_print(Exchange##Type, Xchg, Print); \
ok_eq_print(Compare##Type, Cmp, Print); \
} while(0)

Definition at line 162 of file ExInterlocked.c.

◆ CheckInterlockedOp

#define CheckInterlockedOp (   Function,
  Type,
  Print,
  Val,
  Op,
  ExpectedValue,
  ExpectedRet,
  ... 
)
Value:
do \
{ \
Type Ret##Type = 0; \
Type Value##Type = Val; \
SaveState(OldState); \
Ret##Type = Function(&Value##Type, Op, ##__VA_ARGS__); \
SaveState(NewState); \
CheckState(&OldState, &NewState); \
} _SEH2_END; \
ok_eq_hex(Status, STATUS_SUCCESS); \
ok_eq_print(Ret##Type, ExpectedRet, Print); \
ok_eq_print(Value##Type, ExpectedValue, Print); \
} while (0)

Definition at line 186 of file ExInterlocked.c.

◆ CheckInterlockedOpLarge

#define CheckInterlockedOpLarge (   Function,
  Type,
  Print,
  Val,
  Op,
  ExpectedValue,
  ExpectedRet,
  ... 
)
Value:
do \
{ \
Type Ret##Type = Large(0); \
Type Value##Type = Val; \
SaveState(OldState); \
Ret##Type = Function(&Value##Type, Op, ##__VA_ARGS__); \
SaveState(NewState); \
CheckState(&OldState, &NewState); \
} _SEH2_END; \
ok_eq_hex(Status, STATUS_SUCCESS); \
ok_eq_print(Ret##Type.QuadPart, ExpectedRet, Print); \
ok_eq_print(Value##Type.QuadPart, ExpectedValue, Print); \
} while (0)

Definition at line 224 of file ExInterlocked.c.

◆ CheckInterlockedOpLargeNoRet

#define CheckInterlockedOpLargeNoRet (   Function,
  Type,
  Print,
  Val,
  Op,
  ExpectedValue 
)
Value:
do \
{ \
Type Value##Type = Val; \
SaveState(OldState); \
Function(&Value##Type, Op); \
SaveState(NewState); \
CheckState(&OldState, &NewState); \
} _SEH2_END; \
ok_eq_hex(Status, STATUS_SUCCESS); \
ok_eq_print(Value##Type.QuadPart, ExpectedValue, Print); \
} while (0)

Definition at line 243 of file ExInterlocked.c.

◆ CheckInterlockedOpNoArg

#define CheckInterlockedOpNoArg (   Function,
  Type,
  Print,
  Val,
  ExpectedValue,
  ExpectedRet,
  ... 
)
Value:
do \
{ \
Type Ret##Type = 0; \
Type Value##Type = Val; \
SaveState(OldState); \
Ret##Type = Function(&Value##Type, ##__VA_ARGS__); \
SaveState(NewState); \
CheckState(&OldState, &NewState); \
} _SEH2_END; \
ok_eq_hex(Status, STATUS_SUCCESS); \
ok_eq_print(Ret##Type, ExpectedRet, Print); \
ok_eq_print(Value##Type, ExpectedValue, Print); \
} while (0)

Definition at line 205 of file ExInterlocked.c.

◆ CheckState

#define CheckState (   OldState,
  NewState 
)
Value:
do \
{ \
(void)OldState; \
(void)NewState; \
} while (0)

◆ SaveState

#define SaveState (   State)

Function Documentation

◆ __declspec()

__declspec ( dllimport  )

Definition at line 11 of file ExInterlocked.c.

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}
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
uint64_t ULONGLONG
Definition: typedefs.h:67
LONGLONG QuadPart
Definition: typedefs.h:114

◆ START_TEST()

START_TEST ( ExInterlocked  )

Definition at line 386 of file ExInterlocked.c.

387{
388 KIRQL Irql;
390
391 /* functional testing */
396}
static VOID TestInterlockedFunctional(VOID)
_Out_ PKIRQL Irql
Definition: csq.h:179
UCHAR KIRQL
Definition: env_spec_w32.h:591
#define KeRaiseIrql(irql, oldIrql)
Definition: env_spec_w32.h:597
#define HIGH_LEVEL
Definition: env_spec_w32.h:703
#define KeLowerIrql(oldIrql)
Definition: env_spec_w32.h:602
#define KeInitializeSpinLock(sl)
Definition: env_spec_w32.h:604
_Must_inspect_result_ _In_opt_ PWDF_OBJECT_ATTRIBUTES _Out_ WDFSPINLOCK * SpinLock
Definition: wdfsync.h:228

◆ TestInterlockedFunctional()

static VOID TestInterlockedFunctional ( VOID  )
static

Definition at line 262 of file ExInterlocked.c.

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}
#define CheckInterlockedOp(Function, Type, Print, Val, Op, ExpectedValue, ExpectedRet,...)
#define CheckInterlockedOpLarge(Function, Type, Print, Val, Op, ExpectedValue, ExpectedRet,...)
#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
LONG NTSTATUS
Definition: precomp.h:26
#define U(x)
Definition: wordpad.c:45
#define NULL
Definition: types.h:112
#define InterlockedExchangePointer(Target, Value)
Definition: dshow.h:45
KSPIN_LOCK * PKSPIN_LOCK
Definition: env_spec_w32.h:73
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 L(x)
Definition: ntvdm.h:50
long LONG
Definition: pedump.c:60
int64_t LONGLONG
Definition: typedefs.h:68
uint32_t ULONG
Definition: typedefs.h:59
#define MAXLONG
Definition: umtypes.h:116
#define MINLONG
Definition: umtypes.h:115
#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

Referenced by START_TEST().