dllmain.c

//
//
//

// Online assembler reference ::::
// Online x86 _ x64 Assembler ::: https://defuse.ca/online-x86-assembler.htm#disassembly

// Function pointer code references ::::
// http://www.blitzbasic.com/Community/posts.php?topic=83420
// http://www.blitzbasic.com/codearcs/codearcs.php?code=1639

// Using ESP and EBP ::::
// https://www.powerbasic.com/support/help/pbcc/using_esp_and_ebp.htm

// Notes :: http://tinyurl.com/o6wvlog
// 
// The volatile registers are: EAX, ECX, EDX, ST0 - ST7, ES and GS
// The non-volatile registers are: EBX, EBP, ESP, EDI, ESI, CS and DS


#define WIN32_LEAN_AND_MEAN  /* speed up */
#include <windows.h>
#include <windowsx.h>
#include <commctrl.h>
#include <tchar.h>

#include <stdint.h>
#include <stdbool.h>

#include <stdatomic.h>
// #include <pthread.h>


// #include "ATOMIC32.h"

#define BBDECL extern "C" __declspec(dllexport)
#define BBCALL __stdcall

typedef unsigned int ui;
typedef unsigned long ul;
typedef unsigned long long ull;
typedef int64_t *int64_tp;

 __declspec(dllexport) HANDLE atGetCurrentProcess(void);


// typedef int (*my_intf)(int);   // A function pointer...


 //__declspec(naked) int64_t *interlockedCompareExchange(volatile int64_t *v, int64_t exValue, int64_t cmpValue);
 //__declspec(dllexport) bool casX(volatile ull* addr, ul expected_high, ul expected_low, ul new_high, ul new_low);

//////////////////////// Function prototypes //////////////////////////////////////////////

__declspec(dllexport) bool casX(volatile ull* addr, ul expected_high, ul expected_low, ul new_high, ul new_low);


void (__stdcall *JumpFunction)(void);

// The following functions were created by VirtLands::::

__declspec(naked) __declspec(dllexport) bool cmpxchg8bP(volatile int64_t *mem, int64_t *expected, int64_t *new);

__declspec(naked) __declspec(dllexport) bool cmpxchg_op    (volatile int64_t *mem, int64_t *expected, int64_t *new, ui opsize);
__declspec(naked) __declspec(dllexport) bool cmpxchg_op_off(volatile int64_t *mem, int64_t *expected, int64_t *new, ui opsize, ui offset);

__declspec(naked) __declspec(dllexport) bool cmpxchg_1(volatile ui *mem, ui expected, ui new);
__declspec(naked) __declspec(dllexport) bool cmpxchg_2(volatile ui *mem, ui expected, ui new);
__declspec(naked) __declspec(dllexport) bool cmpxchg_4(volatile ui *mem, ui expected, ui new);

__declspec(naked) __declspec(dllexport) bool cmpxchg_1_nz(volatile ui *mem, ui expected, ui new);
__declspec(naked) __declspec(dllexport) bool cmpxchg_2_nz(volatile ui *mem, ui expected, ui new);
__declspec(naked) __declspec(dllexport) bool cmpxchg_4_nz(volatile ui *mem, ui expected, ui new);
__declspec(naked) __declspec(dllexport) ui cmpxchgSBxor_1(volatile ui *mem, ui expected, ui new);
__declspec(naked) __declspec(dllexport) ui cmpxchgSBxor_2(volatile ui *mem, ui expected, ui new);
__declspec(naked) __declspec(dllexport) ui cmpxchgSBxor_4(volatile ui *mem, ui expected, ui new);

__declspec(naked) __declspec(dllexport) ui xchg_1(volatile int *mem, int v);  // xchg affects no flags
__declspec(naked) __declspec(dllexport) ui xchg_2(volatile int *mem, int v);
__declspec(naked) __declspec(dllexport) ui xchg_4(volatile int *mem, int v);
__declspec(naked) __declspec(dllexport) ui xchg_op(volatile int *mem, int v, int opsize);

__declspec(naked) __declspec(dllexport) ui AtomicAdd_1(volatile int *mem, int v);  // add affects several flags
__declspec(naked) __declspec(dllexport) ui AtomicAdd_2(volatile int *mem, int v);
__declspec(naked) __declspec(dllexport) ui AtomicAdd_4(volatile int *mem, int v);
__declspec(naked) __declspec(dllexport) ui AtomicAdd_1o(volatile int *mem, int v);
__declspec(naked) __declspec(dllexport) ui AtomicAdd_2o(volatile int *mem, int v);
__declspec(naked) __declspec(dllexport) ui AtomicAdd_4o(volatile int *mem, int v);
__declspec(naked) __declspec(dllexport) ui AtomicAdd_1z(volatile int *mem, int v);
__declspec(naked) __declspec(dllexport) ui AtomicAdd_2z(volatile int *mem, int v);
__declspec(naked) __declspec(dllexport) ui AtomicAdd_4z(volatile int *mem, int v);
__declspec(naked) __declspec(dllexport) ui AtomicAdd_4nz(volatile int *mem, int v);

__declspec(naked) __declspec(dllexport) ui AtomicAdd_1f(volatile int *mem, int v);
__declspec(naked) __declspec(dllexport) ui AtomicAdd_2f(volatile int *mem, int v);
__declspec(naked) __declspec(dllexport) ui AtomicAdd_4f(volatile int *mem, int v);


__declspec(naked) __declspec(dllexport) ui AtomicAdc_1(volatile int *mem, ui v, ui c);  // adc affects several flags
__declspec(naked) __declspec(dllexport) ui AtomicAdc_2(volatile int *mem, ui v, ui c);
__declspec(naked) __declspec(dllexport) ui AtomicAdc_4(volatile int *mem, ui v, ui c);
__declspec(naked) __declspec(dllexport) ui AtomicAdc_1o(volatile int *mem, ui v, ui c);
__declspec(naked) __declspec(dllexport) ui AtomicAdc_2o(volatile int *mem, ui v, ui c);
__declspec(naked) __declspec(dllexport) ui AtomicAdc_4o(volatile int *mem, ui v, ui c);
__declspec(naked) __declspec(dllexport) ui AtomicAdc_1z(volatile int *mem, ui v, ui c);
__declspec(naked) __declspec(dllexport) ui AtomicAdc_2z(volatile int *mem, ui v, ui c);
__declspec(naked) __declspec(dllexport) ui AtomicAdc_4z(volatile int *mem, ui v, ui c);
__declspec(naked) __declspec(dllexport) ui AtomicAdc_1f(volatile int *mem, ui v, ui c);
__declspec(naked) __declspec(dllexport) ui AtomicAdc_2f(volatile int *mem, ui v, ui c);
__declspec(naked) __declspec(dllexport) ui AtomicAdc_4f(volatile int *mem, ui v, ui c);


BOOL APIENTRY DllMain(HINSTANCE hInstDLL, DWORD fdwReason, LPVOID lpvReserved)
{
    switch (fdwReason)
    {
        case DLL_PROCESS_ATTACH:
            /*
             * Microsoft says:
             *
             * The DLL is being loaded into the virtual address space of the current
             * process as a result of the process starting up or as a result of a call
             * to LoadLibrary. DLLs can use this opportunity to initialize any instance
             * data or to use the TlsAlloc function to allocate a thread local storage
             * (TLS) index.
             */
            break;

        case DLL_THREAD_ATTACH:
            /*
             * Microsoft says:
             *
             * The current process is creating a new thread. When this occurs, the system
             * calls the entry-point function of all DLLs currently attached to the process.
             * The call is made in the context of the new thread. DLLs can use this opportunity
             * to initialize a TLS slot for the thread. A thread calling the DLL entry-point
             * function with DLL_PROCESS_ATTACH does not call the DLL entry-point function
             * with DLL_THREAD_ATTACH.
             *
             * Note that a DLL's entry-point function is called with this value only by threads
             * created after the DLL is loaded by the process. When a DLL is loaded using
             * LoadLibrary, existing threads do not call the entry-point function of the newly
             * loaded DLL.
             */
            break;

        case DLL_THREAD_DETACH:
            /*
             * Microsoft says:
             *
             * A thread is exiting cleanly. If the DLL has stored a pointer to allocated memory
             * in a TLS slot, it should use this opportunity to free the memory. The system calls
             * the entry-point function of all currently loaded DLLs with this value. The call
             * is made in the context of the exiting thread.
             */
            break;

        case DLL_PROCESS_DETACH:
            /*
             * Microsoft says:
             *
             * The DLL is being unloaded from the virtual address space of the calling process as
             * a result of unsuccessfully loading the DLL, termination of the process, or a call
             * to FreeLibrary. The DLL can use this opportunity to call the TlsFree function to
             * free any TLS indices allocated by using TlsAlloc and to free any thread local data.
             *
             * Note that the thread that receives the DLL_PROCESS_DETACH notification is not
             * necessarily the same thread that received the DLL_PROCESS_ATTACH notification.
             */
            break;
    }

    /* Return success */
    return TRUE;
}

// __declspec( dllexport ) __declspec(naked) int __cdecl summ(int arg1, int arg2)
// BBDECL __declspec( dllexport ) __declspec(naked) int summ(int arg1, int arg2)

 __declspec( dllexport ) __declspec(naked) int summ(int a, int b)
{
  _asm  {
  push ebp
  mov  ebp,esp

  mov eax, [ebp+8]
  add eax, [ebp+12]

  ;mov esp,ebp   ;; use this only if local variables were created
  pop ebp
  ret 8      ;; return 8 bytes 
  }
}



__declspec(naked) int __cdecl naked_sample(int arg1, int arg2)

//__declspec(naked) int _fastcall naked_sample(int arg1, int arg2)
{
    /* prologue */
    __asm {
        push ebp
        mov ebp,esp
        sub esp,__LOCAL_SIZE
        mov [arg1],ecx
        mov [arg2],edx
    }

    /* C code */
    // ext_1 = arg1 * arg2;
    /* ... */

    /* epilogue */
    __asm {
        mov ebp,esp
        pop ebp
        ret
    }
}



// source reference :: http://stackoverflow.com/questions/833122/cmpxchg-example-for-64-bit-integer
// :: _forceinline int64_t interlockedCompareExchange(volatile int64_t & v,int64_t exValue,int64_t cmpValue)
//
__declspec(naked) int64_t *interlockedCompareExchange(volatile int64_t *v, int64_t exValue, int64_t cmpValue)

{
  __asm {
    mov         esi,v
    mov         ebx,dword ptr exValue
    ;mov        ecx,dword ptr exValue + 4
    mov         eax,dword ptr cmpValue
    ;mov        edx,dword ptr cmpValue + 4
    lock cmpxchg8b qword ptr [esi]
    ret
  }
}



// reference :: https://www.cs.sfu.ca/~ashriram/courses/2012/CS885/assignments/Ass1/atomicops.h
// 
 __declspec(dllexport) bool casX(volatile ull* addr, ul expected_high, ul expected_low, ul new_high, ul new_low)
// ......................this code was checked by VirtLands and it works...............
{
    static bool success =0;
    __asm {
        mov eax, expected_low
        mov edx, expected_high
        mov ebx, new_low
        mov ecx, new_high
        mov edi, addr
        lock cmpxchg8b QWORD PTR [edi]
		setz [success]
    }
    return success;
}

// cmpxchg8bP -- by VirtLands,,  This function returns the resultant "Zero Flag", and may affect var "mem".
// for reference :: http://faydoc.tripod.com/cpu/cmpxchg8b.htm
//
// ::: Usage :::
//
// Compare EDX:EAX with m64. If equal, set ZF and load ECX:EBX into m64. Else, clear ZF and load m64 into EDX:EAX
// or...
// Compare "expected" with "mem". If equal, set ZF and load "new" into "mem". Else, clear ZF and load m64 into "expected" = EDX:EAX
//
// EDX:EAX = expected
// EDX:EAX = new
//
// ... In this particular function, the value of EDX:EAX shall eventually be ignored (discarded).
// ... and EAX ultimately takes on the value of the Zero Flag.
// ..............................................this code was checked by VirtLands and it works...............
 __declspec(naked) __declspec(dllexport) bool cmpxchg8bP(volatile int64_t *mem, int64_t *expected, int64_t *new)
{
 __asm {
        push ebp
        mov  ebp,esp 
		push ebx
		push ecx
		push edx
		push edi

		mov edi,[ebp+8]   ;; EDI points to mem
        mov ebx,[ebp+12]
		mov eax,[ebx]     ;; EDX:EAX contains "expected"  
		mov edx,[ebx+4]
		mov ebx,[ebp+16]
        mov ecx,[ebx+4]   ;; ECX:EBX contains "new" 
		mov ebx,[ebx]

        lock cmpxchg8b QWORD PTR [edi]

		setz cl           ;; store the zero flag result into CL
		xor eax,eax
		add al,cl         ;; store CL into EAX, and return EAX

		pop edi
		pop edx
        pop ecx
		pop ebx

        ;mov esp,ebp      ;; <-- not necessary, since no local variables were created.
        pop ebp
        ret 12            ;; return 12 bytes, (= 3 parameters, at 4 bytes each)
       }
}


// In this version of cmpxchg, the user chooses the operand size (opsize)
//    === Opsize can be of the following values ===
//        opsize =1  (BYTE  operand)  =  8 bits
//        opsize =2  (SHORT operand)  = 16 bits
//        opsize =4  (INT   operand)  = 32 bits
//
//        (other values of opsize shall be ignored)
//
 __declspec(naked) __declspec(dllexport) bool cmpxchg_op(volatile int64_t *mem, int64_t *expected, int64_t *new, ui opsize)
{
 __asm {
        push ebp
        mov  ebp,esp 
		push ebx
		push ecx		
		push edi
		push esi

		xor ecx,ecx 
		inc cl            ;; CL =1

		mov esi,[ebp+20]  ;; ESI = opsize
		mov edi,[ebp+8]   ;; EDI points to "mem"

		mov eax,[ebp+12]  ;; EAX = "expected" 
		mov ebx,[ebp+16]  ;; EBX = "new"      

        shr esi,cl
        jc cmpxchg_op1
        shr esi,cl
        jc cmpxchg_op2
        shr esi,cl
        jc cmpxchg_op4
		jmp short cmpxchg_op_exit

  cmpxchg_op1:
		lock cmpxchg [edi],bl       ;; atomic exchange on a Byte.
        jmp short cmpxchg_op_exit
  cmpxchg_op2:
		lock cmpxchg [edi],bx       ;; atomic exchange on a Short.
        jmp short cmpxchg_op_exit
  cmpxchg_op4:
		lock cmpxchg [edi],ebx      ;; atomic exchange on an INT.
        jmp short cmpxchg_op_exit

  cmpxchg_op_exit:

		setz cl           ;; store the zero flag result into CL
		xor eax,eax
		add al,cl         ;; store CL into EAX, and return EAX

	    pop esi
		pop edi		
        pop ecx
		pop ebx
        ;mov esp,ebp      ;; <-- not necessary, since no local variables were created.
        pop ebp
        ret 16            ;; return 16 bytes, (= 4 parameters, at 4 bytes each)
       }
}


// In this version of cmpxchg, the user chooses the operand size (opsize)
//    === Opsize can be of the following values ===
//        opsize =1  (BYTE  operand)  =  8 bits
//        opsize =2  (SHORT operand)  = 16 bits
//        opsize =4  (INT   operand)  = 32 bits
//
//        (other values of opsize shall be ignored)
//    === The "offset" parameter is an offset into "mem"
 __declspec(naked) __declspec(dllexport) bool cmpxchg_op_off(volatile int64_t *mem, int64_t *expected, int64_t *new, ui opsize, ui offset)
{
 __asm {
        push ebp
        mov  ebp,esp 
		push ebx
		push ecx
		push edx
		push edi
		push esi

		xor ecx,ecx 
		inc cl            ;; CL =1

		mov esi,[ebp+20]  ;; ESI = opsize
		mov edi,[ebp+8]   ;; EDI points to "mem"

		mov eax,[ebp+12]  ;; EAX = "expected" 
		mov ebx,[ebp+16]  ;; EBX = "new"      

		mov edx,[ebp+24]  ;; EDX = offset into "mem"

        shr esi,cl
        jc cmpxchg_op1
        shr esi,cl
        jc cmpxchg_op2
        shr esi,cl
        jc cmpxchg_op4
		jmp short cmpxchg_op_exit

  cmpxchg_op1:
		lock cmpxchg [edi+edx],bl       ;; atomic exchange on a Byte.
        jmp short cmpxchg_op_exit
  cmpxchg_op2:
		lock cmpxchg [edi+edx],bx       ;; atomic exchange on a Short.
        jmp short cmpxchg_op_exit
  cmpxchg_op4:
		lock cmpxchg [edi+edx],ebx      ;; atomic exchange on an INT.
        jmp short cmpxchg_op_exit

  cmpxchg_op_exit:

		setz cl           ;; store the zero flag result into CL
		xor eax,eax
		add al,cl         ;; store CL into EAX, and return EAX

	    pop esi
		pop edi
		pop edx
        pop ecx
		pop ebx        
        pop ebp
        ret 20            ;; return 20 bytes, (= 5 parameters, at 4 bytes each)
       }
}



// reference : http://faydoc.tripod.com/cpu/cmpxchg.htm
//
//  This atomic functtion returns the ZF,   (ZF = result of comparison).
//  -------- How it works :: --------
//  "expected" is stored into AL,  (=8 bits) 
//  then compare AL with "mem".    
//  If equal then { ZF=1, and "expected" is stored in mem } 
//  else { ZF=0, and AL=MEM (only temporarily) }
//
__declspec(naked) __declspec(dllexport) bool cmpxchg_1(volatile ui *mem, ui expected, ui new)
{
 __asm {
        push ebp
        mov  ebp,esp 
		push ebx
		push ecx

        mov ebx,[ebp+8]   ;; EBX points to mem
		mov eax,[ebp+12]  ;; EAX = expected;     Only AL shall be used.
		mov ecx,[ebp+16]  ;; ECX = new;          Only CL shall be used

        lock cmpxchg [ebx],cl 

		setz cl           ;; store the zero flag result into CL
		xor eax,eax
		add al,cl         ;; store CL into EAX, and return EAX
  
        pop ecx
		pop ebx        
        pop ebp
        ret 12  
	   }
}

// reference : http://faydoc.tripod.com/cpu/cmpxchg.htm
//
//  This atomic function returns the ZF,   (ZF = result of comparison).
//  -------- How it works :: --------
//  "expected" is stored into AX,  (=16 bits)  
//  then compare AX with "mem".   
//  If equal then { ZF=1, and "expected" is stored in mem } 
//  else { ZF=0, and AX=MEM (only temporarily) }
//
 __declspec(naked) __declspec(dllexport) bool cmpxchg_2(volatile ui *mem, ui expected, ui new)
{
 __asm {
        push ebp
        mov  ebp,esp 
		push ebx
		push ecx

        mov ebx,[ebp+8]   ;; EBX points to mem
		mov eax,[ebp+12]  ;; EAX = expected;     Only AX shall be used.
		mov ecx,[ebp+16]  ;; ECX = new;          Only CX shall be used

        lock cmpxchg [ebx],cx

		setz cl           ;; store the zero flag result into CL
		xor eax,eax
		add al,cl         ;; store CL into EAX, and return EAX
  
        pop ecx
		pop ebx        
        pop ebp
        ret 12  
	   }
}


// reference : http://faydoc.tripod.com/cpu/cmpxchg.htm
//
//  This atomic functtion returns the ZF,   (ZF = result of comparison).
//  -------- How it works :: --------
//  "expected" is stored into EAX,  (=32 bits) 
//  then compare EAX with "mem".  
//  If equal then { ZF=1, and "expected" is stored in mem } 
//  else { ZF=0, and EAX=MEM (only temporarily) }
//
 __declspec(naked) __declspec(dllexport) bool cmpxchg_4(volatile ui *mem, ui expected, ui new)
{
 __asm {
        push ebp
        mov  ebp,esp 
		push ebx
		push ecx

        mov ebx,[ebp+8]   ;; EBX points to mem
		mov eax,[ebp+12]  ;; EAX = expected;   
		mov ecx,[ebp+16]  ;; ECX = new;        

        lock cmpxchg [ebx],ecx

		setz cl           ;; store the zero flag result into CL
		xor eax,eax
		add al,cl         ;; store CL into EAX, and return EAX
  
        pop ecx
		pop ebx        
        pop ebp
        ret 12  
	   }
}


//-----------------------------------------------------------------------------------------------

// reference : http://faydoc.tripod.com/cpu/cmpxchg.htm
//
//  This atomic functtion returns the REVERSE of ZF,   (ZF = result of comparison).
//  -------- How it works :: --------
//  "expected" is stored into AL,  (=8 bits) 
//  then compare AL with "mem".    
//  If equal then { ZF=1, and "expected" is stored in mem } 
//  else { ZF=0, and AL=MEM (only temporarily) }
//
__declspec(naked) __declspec(dllexport) bool cmpxchg_1_nz(volatile ui *mem, ui expected, ui new)
{
 __asm {
        push ebp
        mov  ebp,esp 
		push ebx
		push ecx

        mov ebx,[ebp+8]   ;; EBX points to mem
		mov eax,[ebp+12]  ;; EAX = expected;     Only AL shall be used.
		mov ecx,[ebp+16]  ;; ECX = new;          Only CL shall be used

        lock cmpxchg [ebx],cl

		setnz cl           ;; store the not zero flag result into CL
		xor eax,eax
		add al,cl         ;; store CL into EAX, and return EAX
  
        pop ecx
		pop ebx        
        pop ebp
        ret 12  
	   }
}

// reference : http://faydoc.tripod.com/cpu/cmpxchg.htm
//
//  This atomic functtion returns the REVERSE of  ZF,   (ZF = result of comparison).
//  -------- How it works :: --------
//  "expected" is stored into AX,  (=16 bits)  
//  then compare AX with "mem".   
//  If equal then { ZF=1, and "expected" is stored in mem } 
//  else { ZF=0, and AX=MEM (only temporarily) }
//
 __declspec(naked) __declspec(dllexport) bool cmpxchg_2_nz(volatile ui *mem, ui expected, ui new)
{
 __asm {
        push ebp
        mov  ebp,esp 
		push ebx
		push ecx

        mov ebx,[ebp+8]   ;; EBX points to mem
		mov eax,[ebp+12]  ;; EAX = expected;     Only AX shall be used.
		mov ecx,[ebp+16]  ;; ECX = new;          Only CX shall be used

        lock cmpxchg [ebx],cx

		setnz cl           ;; store the zero flag result into CL
		xor eax,eax
		add al,cl         ;; store CL into EAX, and return EAX
  
        pop ecx
		pop ebx        
        pop ebp
        ret 12  
	   }
}


// reference : http://faydoc.tripod.com/cpu/cmpxchg.htm
//
//  This atomic functtion returns the REVERSE of ZF,   (ZF = result of comparison).
//  -------- How it works :: --------
//  "expected" is stored into EAX,  (=32 bits) 
//  then compare EAX with "mem".  
//  If equal then { ZF=1, and "expected" is stored in mem } 
//  else { ZF=0, and EAX=MEM (only temporarily) }
//
 __declspec(naked) __declspec(dllexport) bool cmpxchg_4_nz(volatile ui *mem, ui expected, ui new)
{
 __asm {
        push ebp
        mov  ebp,esp 
		push ebx
		push ecx

        mov ebx,[ebp+8]   ;; EBX points to mem
		mov eax,[ebp+12]  ;; EAX = expected;   
		mov ecx,[ebp+16]  ;; ECX = new;        

        lock cmpxchg [ebx],ecx

		setnz cl           ;; store the zero flag result into CL
		xor eax,eax
		add al,cl         ;; store CL into EAX, and return EAX
  
        pop ecx
		pop ebx        
        pop ebp
        ret 12  
	   }
}


 __declspec(naked) __declspec(dllexport) unsigned int bitNOT(unsigned int val)
{
 __asm {
        push ebp
        mov  ebp,esp 		
        mov eax,[ebp+8]   ;; EAX = val
        not eax           ;; EAX = NOT EAX      
        pop ebp
        ret  
	   }
}


//-----------------------------------------------------------------------------------------------



//
//  ........one of my weird inventions ........
//
//  This atomic function returns:  AL xor (ZF shl 7)
//  In other words, the sign bit of AL is XORed with the ZF, (where ZF = result of comparison)

//  -------- How it works :: --------
//  "expected" is stored into AL,  (=8 bits) 
//  then compare AL with "mem".    
//  If equal then { ZF=1, and "expected" is stored in mem } 
//  else { ZF=0, and AL=MEM }
//
__declspec(naked) __declspec(dllexport) ui cmpxchgSBxor_1(volatile ui *mem, ui expected, ui new)
{
 __asm {
        push ebp
        mov  ebp,esp 
		push ebx
		push ecx

        mov ebx,[ebp+8]   ;; EBX points to mem
		mov eax,[ebp+12]  ;; EAX = expected;     Only AL shall be used.
		mov ecx,[ebp+16]  ;; ECX = new;          Only CL shall be used

        lock cmpxchg [ebx],cl

		setz cl           ;; store the zero flag result into CL
        shl cl,7

		xor al,cl         ;; The ZF is XORed into sign bit of byte AL.
		  
        pop ecx
		pop ebx        
        pop ebp
        ret 12  
	   }
}

//
//  ........one of my weird inventions ........
//
//  This atomic function returns:  AX xor (ZF shl 15)
//  In other words, the sign bit of AX is XORed with the ZF, (where ZF = result of comparison)

//  -------- How it works :: --------
//  "expected" is stored into AX,  (=16 bits) 
//  then compare AX with "mem".    
//  If equal then { ZF=1, and "expected" is stored in mem } 
//  else { ZF=0, and AX=MEM }
//
__declspec(naked) __declspec(dllexport) ui cmpxchgSBxor_2(volatile ui *mem, ui expected, ui new)
{
 __asm {
        push ebp
        mov  ebp,esp 
		push ebx
		push ecx

        mov ebx,[ebp+8]   ;; EBX points to mem
		mov eax,[ebp+12]  ;; EAX = expected;     Only AX shall be used.
		mov ecx,[ebp+16]  ;; ECX = new;          Only CX shall be used

        lock cmpxchg [ebx],cx

		setz cl           ;; store the zero flag result into CL
        shl cx,15

		xor ax,cx         ;; The ZF is XORed into sign bit of SHORT AX.
		  
        pop ecx
		pop ebx        
        pop ebp
        ret 12  
	   }
}

//
//  ........one of my weird inventions ........
//
//  This atomic function returns:  EAX xor (ZF shl 31)
//  In other words, the sign bit of EAX is XORed with the ZF, (where ZF = result of comparison)

//  -------- How it works :: --------
//  "expected" is stored into EAX,  (=32 bits) 
//  then compare EAX with "mem".    
//  If equal then { ZF=1, and "expected" is stored in mem } 
//  else { ZF=0, and EAX=MEM }
//
__declspec(naked) __declspec(dllexport) ui cmpxchgSBxor_4(volatile ui *mem, ui expected, ui new)
{
 __asm {
        push ebp
        mov  ebp,esp 
		push ebx
		push ecx

        mov ebx,[ebp+8]   ;; EBX points to mem
		mov eax,[ebp+12]  ;; EAX = expected;   
		mov ecx,[ebp+16]  ;; ECX = new;        

        lock cmpxchg [ebx],ecx

		setz cl           ;; store the zero flag result into CL
        shl ecx,31

		xor eax,ecx       ;; The ZF is XORed into sign bit of INT EAX.
		  
        pop ecx
		pop ebx        
        pop ebp
        ret 12  
	   }
}

// reference :: http://tinyurl.com/qfuqwhw
// Does an atomic swap of "mem" and register AL,  (where AL = v), 
// Automically returns the previous "mem" (BYTE).
__declspec(naked) __declspec(dllexport) ui xchg_1(volatile int *mem, int v)
{
 __asm {
        push ebp
        mov  ebp,esp 
		push ebx
        mov ebx,[ebp+8]   ;; EBX points to mem
		mov eax,[ebp+12]  ;; AL = v  

        xchg [ebx],al     ;; (The LOCK prefix is not needed for XCHG.)

		pop ebx        
        pop ebp
        ret 8  
	   }
}


// reference :: http://tinyurl.com/qfuqwhw
// Does an atomic swap of "mem" and register AX,  (where AX = v), 
// and also atomically returns the previous "mem" (SHORT).
__declspec(naked) __declspec(dllexport) ui xchg_2(volatile int *mem, int v)
{
 __asm {
        push ebp
        mov  ebp,esp 
		push ebx
        mov ebx,[ebp+8]   ;; EBX points to mem
		mov eax,[ebp+12]  ;; AX = v  
        xchg [ebx],ax    
		pop ebx        
        pop ebp
        ret 8  
	   }
}

// reference :: http://tinyurl.com/qfuqwhw
// Does an atomic swap of "mem" and register EAX,  (where EAX = v), 
// and also atomically returns the previous "mem" (INT).
__declspec(naked) __declspec(dllexport) ui xchg_4(volatile int *mem, int v)
{
 __asm {
        push ebp
        mov  ebp,esp 
		push ebx
        mov ebx,[ebp+8]   ;; EBX points to mem
		mov eax,[ebp+12]  ;; EAX = v  
        xchg [ebx],eax    
		pop ebx        
        pop ebp
        ret 8  
	   }
}

// reference :: http://tinyurl.com/qfuqwhw
// Does an atomic swap of "mem" and register EAX,  (where EAX = v), 
// and also atomically returns the previous "mem" (INT).
//      opsize can be 1,2,4
__declspec(naked) __declspec(dllexport) ui xchg_op(volatile int *mem, int v, int opsize)
{
 __asm {
        push ebp
        mov  ebp,esp 
		push ebx
		push ecx
		push edx

		sub ecx,ecx    
		inc cx        ;; CL =1

        mov ebx,[ebp+8]   ;; EBX points to mem
		mov eax,[ebp+12]  ;; EAX = v  
        mov edx,[ebp+16]  ;; edx = opsize

		shr dl,cl
		jc xchg_op1
		shr dl,cl
		jc xchg_op2
		shr dl,cl
		jc xchg_op4
		jmp short xchg_op_exit

    xchg_op1: 
		xchg [ebx],al  
		jmp short xchg_op_exit

    xchg_op2: 
		xchg [ebx],ax 
		jmp short xchg_op_exit

    xchg_op4: 
		xchg [ebx],eax 

	xchg_op_exit:

		pop edx
        pop ecx
		pop ebx        
        pop ebp
        ret 12  
	   }
}


//////////////////////////////////////////////////////////////////////////////////////////////////////

// Does an atomic add of "mem" and a byte value.
// Returns EAX=v.
__declspec(naked) __declspec(dllexport) ui AtomicAdd_1(volatile int *mem, int v)
{
 __asm {
        push ebp
        mov  ebp,esp 
		push ebx
        mov ebx,[ebp+8]   ;; EBX points to mem
		mov eax,[ebp+12]  ;; EAX = v  
        lock add [ebx],al    
		pop ebx        
        pop ebp
        ret 8  
	   }
}

// Does an atomic add of "mem" and a short value.
// Returns EAX=v.
__declspec(naked) __declspec(dllexport) ui AtomicAdd_2(volatile int *mem, int v)
{
 __asm {
        push ebp
        mov  ebp,esp 
		push ebx
        mov ebx,[ebp+8]   ;; EBX points to mem
		mov eax,[ebp+12]  ;; EAX = v  
        lock add [ebx],ax    
		pop ebx        
        pop ebp
        ret 8  
	   }
}

// Does an atomic add of "mem" and an INT value.
// Returns EAX=v.
__declspec(naked) __declspec(dllexport) ui AtomicAdd_4(volatile int *mem, int v)
{
 __asm {
        push ebp
        mov  ebp,esp 
		push ebx
        mov ebx,[ebp+8]   ;; EBX points to mem
		mov eax,[ebp+12]  ;; EAX = v  
        lock add [ebx],eax    
		pop ebx        
        pop ebp
        ret 8  
	   }
}

//  Does an atomic add of "mem" and a byte value.
//  Atomically returns the overflow flag.  (Set to 1 if overflow, else set to 0).
__declspec(naked) __declspec(dllexport) ui AtomicAdd_1o(volatile int *mem, int v)
{
 __asm {
        push ebp
        mov  ebp,esp 
		push ebx
        mov ebx,[ebp+8]   ;; EBX points to mem
		mov eax,[ebp+12]  ;; EAX = v  
        lock add [ebx],al    
        seto bl
		xor eax,eax
		add al,bl     ;; EAX = overflow flag
		pop ebx        
        pop ebp
        ret 8  
	   }
}

// Does an atomic add of "mem" and a short value.
//  Atomically returns the overflow flag.  (Set to 1 if overflow, else set to 0).
__declspec(naked) __declspec(dllexport) ui AtomicAdd_2o(volatile int *mem, int v)
{
 __asm {
        push ebp
        mov  ebp,esp 
		push ebx
        mov ebx,[ebp+8]   ;; EBX points to mem
		mov eax,[ebp+12]  ;; EAX = v  
        lock add [ebx],ax  
        seto bl
		xor eax,eax
		add al,bl     ;; EAX = overflow flag  
		pop ebx        
        pop ebp
        ret 8  
	   }
}

//  Does an atomic add of "mem" and an INT value.
//  Atomically returns the overflow flag.  (Set to 1 if overflow, else set to 0).
__declspec(naked) __declspec(dllexport) ui AtomicAdd_4o(volatile int *mem, int v)
{
 __asm {
        push ebp
        mov  ebp,esp 
		push ebx
        mov ebx,[ebp+8]   ;; EBX points to mem
		mov eax,[ebp+12]  ;; EAX = v  
        lock add [ebx],eax 
        seto bl
		xor eax,eax
		add al,bl     ;; EAX = overflow flag
		pop ebx        
        pop ebp
        ret 8  
	   }
}

//////////////////////////////////////////////////////////////////////////////////////////////////////

//  Does an atomic add of "mem" and a byte value.
//  Atomically returns the ZF (zero flag).  ( ZF=1 when zero, else ZF=0 when not zero).
__declspec(naked) __declspec(dllexport) ui AtomicAdd_1z(volatile int *mem, int v)
{
 __asm {
        push ebp
        mov  ebp,esp 
		push ebx
        mov ebx,[ebp+8]   ;; EBX points to mem
		mov eax,[ebp+12]  ;; EAX = v 
        lock add [ebx],al
        setz bl
		xor eax,eax
		add al,bl     ;; EAX = zero flag 
		pop ebx        
        pop ebp
        ret 8  
	   }
}

// Does an atomic add of "mem" and a short value.
//  Atomically returns the ZF (zero flag).  ( ZF=1 when zero, else ZF=0 when not zero).
__declspec(naked) __declspec(dllexport) ui AtomicAdd_2z(volatile int *mem, int v)
{
 __asm {
        push ebp
        mov  ebp,esp 
		push ebx
        mov ebx,[ebp+8]   ;; EBX points to mem
		mov eax,[ebp+12]  ;; EAX = v 
        lock add [ebx],ax 
        setz bl
		xor eax,eax
		add al,bl     ;; EAX = zero flag
		pop ebx        
        pop ebp
        ret 8  
	   }
}

//  Does an atomic add of "mem" and an INT value.
//  Atomically returns the ZF (zero flag).  ( ZF=1 when zero, else ZF=0 when not zero).
__declspec(naked) __declspec(dllexport) ui AtomicAdd_4z(volatile int *mem, int v)
{
 __asm {
        push ebp
        mov  ebp,esp 
		push ebx
        mov ebx,[ebp+8]   ;; EBX points to mem
		mov eax,[ebp+12]  ;; EAX = v 
        lock add [ebx],eax
        setz bl
		xor eax,eax
		add al,bl     ;; EAX = zero flag
		pop ebx        
        pop ebp
        ret 8  
	   }
}

//  Does an atomic add of "mem" and an INT value.
//  Atomically returns the NOT ZF (= not zero flag).  
__declspec(naked) __declspec(dllexport) ui AtomicAdd_4nz(volatile int *mem, int v)
{
 __asm {
        push ebp
        mov  ebp,esp 
		push ebx
        mov ebx,[ebp+8]   ;; EBX points to mem
		mov eax,[ebp+12]  ;; EAX = v 
        lock add [ebx],eax
        setnz bl
		xor eax,eax
		add al,bl     ;; EAX = zero flag
		pop ebx        
        pop ebp
        ret 8  
	   }
}


//////////////////////////////////////////////////////////////////////////////////////////////////////

//  Does an atomic add of "mem" and a byte value.
//  Returns atomically updated Eflags (32-bit flags result).  
__declspec(naked) __declspec(dllexport) ui AtomicAdd_1f(volatile int *mem, int v)
{
 __asm {
        push ebp
        mov  ebp,esp 
		push ebx
        push ecx
		xor eax,eax       ;; EAX=0
        mov ebx,[ebp+8]   ;; EBX points to mem
		mov ecx,[ebp+12]  ;; ECX = v  
        lock add [ebx],cl 
		pushfd
		pop eax     ;; EAX now contains the 32-bit flags. 
		pop ecx
		pop ebx        
        pop ebp
        ret 8  
	   }
}

//  Does an atomic add of "mem" and a short value.
//  Returns atomically updated Eflags (32-bit flags result).  
__declspec(naked) __declspec(dllexport) ui AtomicAdd_2f(volatile int *mem, int v)
{
 __asm {
        push ebp
        mov  ebp,esp 
		push ebx
        push ecx
		xor eax,eax       ;; EAX=0
        mov ebx,[ebp+8]   ;; EBX points to mem
		mov ecx,[ebp+12]  ;; ECX = v  
        lock add [ebx],cx   
		pushfd
		pop eax     ;; EAX now contains the 32-bit flags. 
		pop ecx
		pop ebx        
        pop ebp
        ret 8  
	   }
}

//  Does an atomic add of "mem" and an INT value.
//  Returns atomically updated Eflags (32-bit flags result).  
__declspec(naked) __declspec(dllexport) ui AtomicAdd_4f(volatile int *mem, int v)
{
 __asm {
        push ebp
        mov  ebp,esp 
		push ebx
        push ecx
		xor eax,eax       ;; EAX=0
        mov ebx,[ebp+8]   ;; EBX points to mem
		mov ecx,[ebp+12]  ;; ECX = v  
        lock add [ebx],ecx   
		pushfd
		pop eax     ;; EAX now contains the 32-bit flags. 
		pop ecx
		pop ebx        
        pop ebp
        ret 8  
	   }
}

//////////////////////////////////////////////////////////////////////////////////////////////////////
//old


// Does an atomic adc of "mem" and a byte value.
// Returns EAX=v.
__declspec(naked) __declspec(dllexport) ui AtomicAdc_1(volatile int *mem, ui v, ui c)
{
 __asm {
        push ebp
        mov  ebp,esp 
		push ebx
        push ecx
	    mov eax,[ebp+12]     ;; EAX = v
	    mov ebx,[ebp+8]      ;; EBX points to mem
		mov ecx,[ebp+16]     ;; ECX = carry value (= 0 or 1)
		and ecx,1            ;; make sure ecx is <= 1
		shr cl,cl            ;; get the carry 
        lock adc [ebx],al    ;; ADC on a byte value. 
		pop ecx
		pop ebx        
        pop ebp
        ret 12  
	   }
}

// Does an atomic adc of "mem" and a short value.
// Returns EAX=v.
__declspec(naked) __declspec(dllexport) ui AtomicAdc_2(volatile int *mem, ui v, ui c)
{
 __asm {
        push ebp
        mov  ebp,esp 
		push ebx
        push ecx
	    mov eax,[ebp+12]     ;; EAX = v
	    mov ebx,[ebp+8]      ;; EBX points to mem
		mov ecx,[ebp+16]     ;; ECX = carry value (= 0 or 1)
		and ecx,1            ;; make sure ecx is <= 1
		shr cl,cl            ;; get the carry 
        lock adc [ebx],ax    ;; ADC on an INT value. 
		pop ecx
		pop ebx        
        pop ebp
        ret 12  
	   }
}

// Does an atomic adc of "mem" and an INT value.
// Returns EAX=v.
__declspec(naked) __declspec(dllexport) ui AtomicAdc_4(volatile int *mem, ui v, ui c)
{
 __asm {
        push ebp
        mov  ebp,esp 
		push ebx
        push ecx
	    mov eax,[ebp+12]     ;; EAX = v
	    mov ebx,[ebp+8]      ;; EBX points to mem
		mov ecx,[ebp+16]     ;; ECX = carry value (= 0 or 1)
		and ecx,1            ;; make sure ecx is <= 1
		shr cl,cl            ;; get the carry 
        lock adc [ebx],eax   ;; ADC on an INT value. 
		pop ecx
		pop ebx        
        pop ebp
        ret 12  
	   }
}

//  Does an atomic adc of "mem" and a byte value.
//  Atomically returns the overflow flag.  (Set to 1 if overflow, else set to 0).
__declspec(naked) __declspec(dllexport) ui AtomicAdc_1o(volatile int *mem, ui v, ui c)
{
 __asm {
        push ebp
        mov  ebp,esp 
		push ebx
        push ecx
	    mov eax,[ebp+12]     ;; EAX = v
	    mov ebx,[ebp+8]      ;; EBX points to mem
		mov ecx,[ebp+16]     ;; ECX = carry value (= 0 or 1)
		and ecx,1            ;; make sure ecx is <= 1
		shr cl,cl            ;; get the carry 
        lock adc [ebx],al    ;; ADC on a byte
        seto cl
		xor eax,eax
		add al,cl     ;; EAX = overflow flag 
		pop ecx
		pop ebx        
        pop ebp
        ret 12  
	   }
}

// Does an atomic adc of "mem" and a short value.
//  Atomically returns the overflow flag.  (Set to 1 if overflow, else set to 0).
__declspec(naked) __declspec(dllexport) ui AtomicAdc_2o(volatile int *mem, ui v, ui c)
{
 __asm {
        push ebp
        mov  ebp,esp 
		push ebx
        push ecx
	    mov eax,[ebp+12]     ;; EAX = v
	    mov ebx,[ebp+8]      ;; EBX points to mem
		mov ecx,[ebp+16]     ;; ECX = carry value (= 0 or 1)
		and ecx,1            ;; make sure ecx is <= 1
		shr cl,cl            ;; get the carry 
        lock adc [ebx],ax    ;; ADC on a 2-byte value
        seto cl
		xor eax,eax
		add al,cl     ;; EAX = overflow flag 
		pop ecx
		pop ebx        
        pop ebp
        ret 12  
	   }
}

// Does an atomic adc of "mem" and an INT value.
//  Atomically returns the overflow flag.  (Set to 1 if overflow, else set to 0).
__declspec(naked) __declspec(dllexport) ui AtomicAdc_4o(volatile int *mem, ui v, ui c)
{
 __asm {
        push ebp
        mov  ebp,esp 
		push ebx
        push ecx
	    mov eax,[ebp+12]     ;; EAX = v
	    mov ebx,[ebp+8]      ;; EBX points to mem
		mov ecx,[ebp+16]     ;; ECX = carry value (= 0 or 1)
		and ecx,1            ;; make sure ecx is <= 1
		shr cl,cl            ;; get the carry 
        lock adc [ebx],eax   ;; ADC on an INT value
        seto cl
		xor eax,eax
		add al,cl     ;; EAX = overflow flag 
		pop ecx
		pop ebx        
        pop ebp
        ret 12  
	   }
}

//////////////////////////////////////////////////////////////////////////////////////////////////////

//  Does an atomic adc of "mem" and a byte value.
//  Atomically returns the ZF (zero flag).  ( ZF=1 when zero, else ZF=0 when not zero).
__declspec(naked) __declspec(dllexport) ui AtomicAdc_1z(volatile int *mem, ui v, ui c)
{
 __asm {
        push ebp
        mov  ebp,esp 
		push ebx
        push ecx
	    mov eax,[ebp+12]    ;; EAX = v
	    mov ebx,[ebp+8]     ;; EBX points to mem
		mov ecx,[ebp+16]    ;; ECX = carry value (= 0 or 1)
		and ecx,1           ;; make sure ecx is <= 1
		shr cl,cl           ;; get the carry 
        lock adc [ebx],al   ;; ADC on a byte value
        setz cl
 		xor eax,eax
 		add al,cl           ;; EAX = zero flag 
		pop ecx
		pop ebx        
        pop ebp
        ret 12  
	   }
}

//  Does an atomic adc of "mem" and a short value.
//  Atomically returns the ZF (zero flag).  ( ZF=1 when zero, else ZF=0 when not zero).
__declspec(naked) __declspec(dllexport) ui AtomicAdc_2z(volatile int *mem, ui v, ui c)
{
 __asm {
        push ebp
        mov  ebp,esp 
		push ebx
        push ecx
	    mov eax,[ebp+12]    ;; EAX = v
	    mov ebx,[ebp+8]     ;; EBX points to mem
		mov ecx,[ebp+16]    ;; ECX = carry value (= 0 or 1)
		and ecx,1           ;; make sure ecx is <= 1
		shr cl,cl           ;; get the carry   
        lock adc [ebx],ax   ;; ADC on a byte value
        setz cl
 		xor eax,eax
 		add al,cl           ;; EAX = zero flag 
		pop ecx
		pop ebx        
        pop ebp
        ret 12  
	   }
}

//  Does an atomic adc of "mem" and an INT value.
//  Atomically returns the ZF (zero flag).  ( ZF=1 when zero, else ZF=0 when not zero).
__declspec(naked) __declspec(dllexport) ui AtomicAdc_4z(volatile int *mem, ui v, ui c)
{
 __asm {
        push ebp
        mov  ebp,esp 
		push ebx
        push ecx
	    mov eax,[ebp+12]    ;; EAX = v
	    mov ebx,[ebp+8]     ;; EBX points to mem
		mov ecx,[ebp+16]    ;; ECX = carry value (= 0 or 1)
		and ecx,1           ;; make sure ecx is <= 1
		shr cl,cl           ;; get the carry 
        lock adc [ebx],eax   ;; ADC on a byte value
        setz cl
 		xor eax,eax
 		add al,cl           ;; EAX = zero flag 
		pop ecx
		pop ebx        
        pop ebp
        ret 12  
	   }
}


//////////////////////////////////////////////////////////////////////////////////////////////////////

//  Does an atomic adc of "mem" and a byte value
//  Returns atomically updated Eflags (32-bit flags result).  
__declspec(naked) __declspec(dllexport) ui AtomicAdc_1f(volatile int *mem, ui v, ui c)
{
 __asm {
        push ebp
        mov  ebp,esp 
		push ebx
        push ecx
		mov eax,[ebp+16]   ;; EAX = carry value (= 0 or 1
        mov ebx,[ebp+8]    ;; EBX points to mem
		mov ecx,[ebp+12]   ;; ECX = v  
		shr ax,1           ;; get the carry 
        lock adc [ebx],cl  ;; ADC on a BYTE value
		pushfd
		pop eax     ;; EAX now contains the 32-bit flags. 
		pop ecx
		pop ebx        
        pop ebp
        ret 12  
	   }
}

//  Does an atomic adc of "mem" and a short value.
//  Returns atomically updated Eflags (32-bit flags result).  
__declspec(naked) __declspec(dllexport) ui AtomicAdc_2f(volatile int *mem, ui v, ui c)
{
 __asm {
        push ebp
        mov  ebp,esp 
		push ebx
        push ecx
		mov eax,[ebp+16]   ;; EAX = carry value (= 0 or 1
        mov ebx,[ebp+8]    ;; EBX points to mem
		mov ecx,[ebp+12]   ;; ECX = v  
		shr ax,1           ;; get the carry
        lock adc [ebx],cx  ;; ADC on a 2-BYTE value,  (2 bytes =SHORT)
		pushfd
		pop eax     ;; EAX now contains the 32-bit flags. 
		pop ecx
		pop ebx        
        pop ebp
        ret 12  
	   }
}

//  Does an atomic adc of "mem" and an INT value.
//  Returns atomically updated Eflags (32-bit flags result).  
__declspec(naked) __declspec(dllexport) ui AtomicAdc_4f(volatile int *mem, ui v, ui c)
{
 __asm {
        push ebp
        mov  ebp,esp 
		push ebx
        push ecx
		mov eax,[ebp+16]   ;; EAX = carry value (= 0 or 1
        mov ebx,[ebp+8]    ;; EBX points to mem
		mov ecx,[ebp+12]   ;; ECX = v  
		shr ax,1           ;; get the carry    
        lock adc [ebx],ecx  ;; ADC on an INT value
		pushfd
		pop eax     ;; EAX now contains the 32-bit flags. 
		pop ecx
		pop ebx        
        pop ebp
        ret 12  
	   }
}

//////////////////////////////////////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////////////////////////////////////////


 __declspec(dllexport) HANDLE atGetCurrentProcess(void)
{
   return GetCurrentProcess();   
}