Merge 34703, 34704, 34705, 34706, 34707, 34708, 34709 and 34710 from ros-amd64-bringup branch:

- Fix inline versions of integer <-> pointer conversion functions.
- Implement _InterlockedAnd64, _InterlockedOr64, _interlockedbittestandreset64, _interlockedbittestandset64 and gs-segment-adressing functions
- As amd64 shares most of the intrinsics of x86, implement them in intrin_x86.h
- Fix IMAGE_FIRST_SECTION macro
- Implement GetCurrentFiber(), NtCurrentTeb() and YieldProcessor()
- Fix ENUMRESLANGPROC, ENUMRESNAMEPROC and ENUMRESTYPEPROC
- Add Interlocked functions for pointers
- Add InterlockedCompareExchangePointer and InterlockedExchangePointer
- Add intrinsic port and register access functions
fix LIST_ENTRY() macro for 64 bits
add size_t definition to _mingw.h (ported from mingw)
- Update some loader structs ULONG -> ULONG_PTR / SIZE_T

svn path=/trunk/; revision=35636

reactos/include/crt/_mingw.h

@@ -178,6 +178,20 @@
 # define __MSVCRT_VERSION__ 0x0600
 #endif
 
+#ifndef _SIZE_T_DEFINED
+#define _SIZE_T_DEFINED
+#undef size_t
+#ifdef _WIN64
+#if defined(__GNUC__) && defined(__STRICT_ANSI__)
+  typedef unsigned int size_t __attribute__ ((mode (DI)));
+#else
+  typedef unsigned __int64 size_t;
+#endif
+#else
+  typedef unsigned int size_t;
+#endif
+#endif
+
 #define __MINGW32_VERSION 3.13
 #define __MINGW32_MAJOR_VERSION 3
 #define __MINGW32_MINOR_VERSION 13

reactos/include/ddk/winddk.h

@@ -5744,8 +5744,12 @@ InterlockedExchangeAdd(
  *   IN OUT PVOID VOLATILE  *Target,
  *   IN PVOID  Value)
  */
+#if defined (_M_AMD64)
+#define InterlockedExchangePointer _InterlockedExchangePointer
+#else
 #define InterlockedExchangePointer(Target, Value) \
   ((PVOID) InterlockedExchange((PLONG) Target, (LONG) Value))
+#endif
 
 /*
  * PVOID
@@ -5754,8 +5758,12 @@ InterlockedExchangeAdd(
  *   IN PVOID  Exchange,
  *   IN PVOID  Comparand)
  */
+#if defined (_M_AMD64)
+#define InterlockedCompareExchangePointer _InterlockedCompareExchangePointer
+#else
 #define InterlockedCompareExchangePointer(Destination, Exchange, Comparand) \
   ((PVOID) InterlockedCompareExchange((PLONG) Destination, (LONG) Exchange, (LONG) Comparand))
+#endif
 
 #define InterlockedExchangeAddSizeT(a, b) InterlockedExchangeAdd((LONG *)a, b)
 #define InterlockedIncrementSizeT(a) InterlockedIncrement((LONG *)a)
@@ -7569,6 +7577,9 @@ IoAllocateAdapterChannel(
     IN PVOID Context
 );
 
+/** Io access routines **/
+
+#if !defined(_M_AMD64)
 NTHALAPI
 VOID
 NTAPI
@@ -7743,6 +7754,244 @@ WRITE_REGISTER_USHORT(
   IN PUSHORT  Register,
   IN USHORT  Value);
 
+#else
+
+FORCEINLINE
+VOID
+READ_PORT_BUFFER_UCHAR(
+  IN PUCHAR  Port,
+  IN PUCHAR  Buffer,
+  IN ULONG  Count)
+{
+    __inbytestring((USHORT)(ULONG_PTR)Port, Buffer, Count);
+}
+
+FORCEINLINE
+VOID
+READ_PORT_BUFFER_ULONG(
+  IN PULONG  Port,
+  IN PULONG  Buffer,
+  IN ULONG  Count)
+{
+    __indwordstring((USHORT)(ULONG_PTR)Port, Buffer, Count);
+}
+
+FORCEINLINE
+VOID
+READ_PORT_BUFFER_USHORT(
+  IN PUSHORT  Port,
+  IN PUSHORT  Buffer,
+  IN ULONG  Count)
+{
+    __inwordstring((USHORT)(ULONG_PTR)Port, Buffer, Count);
+}
+
+FORCEINLINE
+UCHAR
+READ_PORT_UCHAR(
+  IN PUCHAR  Port)
+{
+    return __inbyte((USHORT)(ULONG_PTR)Port);
+}
+
+FORCEINLINE
+ULONG
+READ_PORT_ULONG(
+  IN PULONG  Port)
+{
+    return __indword((USHORT)(ULONG_PTR)Port);
+}
+
+FORCEINLINE
+USHORT
+READ_PORT_USHORT(
+  IN PUSHORT  Port)
+{
+    return __inword((USHORT)(ULONG_PTR)Port);
+}
+
+FORCEINLINE
+VOID
+READ_REGISTER_BUFFER_UCHAR(
+  IN PUCHAR  Register,
+  IN PUCHAR  Buffer,
+  IN ULONG  Count)
+{
+    __movsb(Register, Buffer, Count);
+}
+
+FORCEINLINE
+VOID
+READ_REGISTER_BUFFER_ULONG(
+  IN PULONG  Register,
+  IN PULONG  Buffer,
+  IN ULONG  Count)
+{
+    __movsd(Register, Buffer, Count);
+}
+
+FORCEINLINE
+VOID
+READ_REGISTER_BUFFER_USHORT(
+  IN PUSHORT  Register,
+  IN PUSHORT  Buffer,
+  IN ULONG  Count)
+{
+    __movsw(Register, Buffer, Count);
+}
+
+FORCEINLINE
+UCHAR
+READ_REGISTER_UCHAR(
+  IN PUCHAR Register)
+{
+    return *Register;
+}
+
+FORCEINLINE
+ULONG
+READ_REGISTER_ULONG(
+  IN PULONG Register)
+{
+    return *Register;
+}
+
+FORCEINLINE
+USHORT
+READ_REGISTER_USHORT(
+  IN PUSHORT Register)
+{
+    return *Register;
+}
+
+FORCEINLINE
+VOID
+WRITE_PORT_BUFFER_UCHAR(
+  IN PUCHAR  Port,
+  IN PUCHAR  Buffer,
+  IN ULONG  Count)
+{
+    __outbytestring((USHORT)(ULONG_PTR)Port, Buffer, Count);
+}
+
+FORCEINLINE
+VOID
+WRITE_PORT_BUFFER_ULONG(
+  IN PULONG  Port,
+  IN PULONG  Buffer,
+  IN ULONG  Count)
+{
+    __outdwordstring((USHORT)(ULONG_PTR)Port, Buffer, Count);
+}
+
+FORCEINLINE
+VOID
+WRITE_PORT_BUFFER_USHORT(
+  IN PUSHORT  Port,
+  IN PUSHORT  Buffer,
+  IN ULONG  Count)
+{
+    __outwordstring((USHORT)(ULONG_PTR)Port, Buffer, Count);
+}
+
+FORCEINLINE
+VOID
+WRITE_PORT_UCHAR(
+  IN PUCHAR  Port,
+  IN UCHAR  Value)
+{
+    __outbyte((USHORT)(ULONG_PTR)Port, Value);
+}
+
+FORCEINLINE
+VOID
+WRITE_PORT_ULONG(
+  IN PULONG  Port,
+  IN ULONG  Value)
+{
+    __outdword((USHORT)(ULONG_PTR)Port, Value);
+}
+
+FORCEINLINE
+VOID
+WRITE_PORT_USHORT(
+  IN PUSHORT  Port,
+  IN USHORT  Value)
+{
+    __outword((USHORT)(ULONG_PTR)Port, Value);
+}
+
+FORCEINLINE
+VOID
+WRITE_REGISTER_BUFFER_UCHAR(
+  IN PUCHAR  Register,
+  IN PUCHAR  Buffer,
+  IN ULONG  Count)
+{
+    LONG Synch;
+    __movsb(Register, Buffer, Count);
+    InterlockedOr(&Synch, 1);
+}
+
+FORCEINLINE
+VOID
+WRITE_REGISTER_BUFFER_ULONG(
+  IN PULONG  Register,
+  IN PULONG  Buffer,
+  IN ULONG  Count)
+{
+    LONG Synch;
+    __movsd(Register, Buffer, Count);
+    InterlockedOr(&Synch, 1);
+}
+
+FORCEINLINE
+VOID
+WRITE_REGISTER_BUFFER_USHORT(
+  IN PUSHORT  Register,
+  IN PUSHORT  Buffer,
+  IN ULONG  Count)
+{
+    LONG Synch;
+    __movsw(Register, Buffer, Count);
+    InterlockedOr(&Synch, 1);
+}
+
+FORCEINLINE
+VOID
+WRITE_REGISTER_UCHAR(
+  IN PUCHAR  Register,
+  IN UCHAR  Value)
+{
+    LONG Synch;
+    *Register = Value;
+    InterlockedOr(&Synch, 1);
+}
+
+FORCEINLINE
+VOID
+WRITE_REGISTER_ULONG(
+  IN PULONG  Register,
+  IN ULONG  Value)
+{
+    LONG Synch;
+    *Register = Value;
+    InterlockedOr(&Synch, 1);
+}
+
+FORCEINLINE
+VOID
+WRITE_REGISTER_USHORT(
+  IN PUSHORT  Register,
+  IN USHORT  Value)
+{
+	LONG Sync;
+	*Register = Value;
+	InterlockedOr(&Sync, 1);
+}
+
+#endif
+
 /** I/O manager routines **/
 
 NTKERNELAPI

reactos/include/psdk/basetsd.h

@@ -65,37 +65,36 @@ typedef unsigned __int64 HANDLE_PTR;
 typedef unsigned int UHALF_PTR, *PUHALF_PTR;
 typedef int HALF_PTR, *PHALF_PTR;
 
-#if 0 /* TODO when WIN64 is here */
+#if !defined(__midl) && !defined(__WIDL__)
-inline unsigned long HandleToUlong(const void* h )
+static inline unsigned long HandleToUlong(const void* h )
-    { return((unsigned long) h ); }
+    { return((unsigned long)(ULONG_PTR) h ); }
-inline long HandleToLong( const void* h )
+static inline long HandleToLong( const void* h )
-    { return((long) h ); }
+    { return((long)(LONG_PTR) h ); }
-inline void* ULongToHandle( const long h )
+static inline void* ULongToHandle( const long h )
     { return((void*) (UINT_PTR) h ); }
-inline void* LongToHandle( const long h )
+static inline void* LongToHandle( const long h )
     { return((void*) (INT_PTR) h ); }
-inline unsigned long PtrToUlong( const void* p)
+static inline unsigned long PtrToUlong( const void* p)
-    { return((unsigned long) p ); }
+    { return((unsigned long)(ULONG_PTR) p ); }
-inline unsigned int PtrToUint( const void* p )
+static inline unsigned int PtrToUint( const void* p )
-    { return((unsigned int) p ); }
+    { return((unsigned int)(UINT_PTR) p ); }
-inline unsigned short PtrToUshort( const void* p )
+static inline unsigned short PtrToUshort( const void* p )
-    { return((unsigned short) p ); }
+    { return((unsigned short)(ULONG_PTR) p ); }
-inline long PtrToLong( const void* p )
+static inline long PtrToLong( const void* p )
-    { return((long) p ); }
+    { return((long)(LONG_PTR) p ); }
-inline int PtrToInt( const void* p )
+static inline int PtrToInt( const void* p )
-    { return((int) p ); }
+    { return((int)(INT_PTR) p ); }
-inline short PtrToShort( const void* p )
+static inline short PtrToShort( const void* p )
-    { return((short) p ); }
+    { return((short)(INT_PTR) p ); }
-inline void* IntToPtr( const int i )
+static inline void* IntToPtr( const int i )
     { return( (void*)(INT_PTR)i ); }
-inline void* UIntToPtr(const unsigned int ui)
+static inline void* UIntToPtr(const unsigned int ui)
     { return( (void*)(UINT_PTR)ui ); }
-inline void* LongToPtr( const long l )
+static inline void* LongToPtr( const long l )
     { return( (void*)(LONG_PTR)l ); }
-inline void* ULongToPtr( const unsigned long ul )
+static inline void* ULongToPtr( const unsigned long ul )
     { return( (void*)(ULONG_PTR)ul ); }
-#endif /* 0_ */
+#endif /* !__midl */
-
 #else /*  !_WIN64 */
 typedef int INT_PTR, *PINT_PTR;
 typedef unsigned int UINT_PTR, *PUINT_PTR;

reactos/include/psdk/intrin.h

@@ -79,7 +79,7 @@
 #include "intrin_arm.h"
 #elif defined(__x86_64__)
 /* TODO: the x64 architecture shares most of the i386 intrinsics. It should be easy to support */
-#include "intrin_x86_64.h"
+#include "intrin_x86.h"
 #else
 #error Unsupported architecture
 #endif

reactos/include/psdk/intrin_x86.h

@@ -153,6 +153,13 @@ static __inline__ __attribute__((always_inline)) long _InterlockedAnd(volatile l
 	return __sync_fetch_and_and(value, mask);
 }
 
+#if defined(_M_AMD64)
+static __inline__ __attribute__((always_inline)) long _InterlockedAnd64(volatile long long * const value, const long long mask)
+{
+	return __sync_fetch_and_and(value, mask);
+}
+#endif
+
 static __inline__ __attribute__((always_inline)) char _InterlockedOr8(volatile char * const value, const char mask)
 {
 	return __sync_fetch_and_or(value, mask);
@@ -168,6 +175,13 @@ static __inline__ __attribute__((always_inline)) long _InterlockedOr(volatile lo
 	return __sync_fetch_and_or(value, mask);
 }
 
+#if defined(_M_AMD64)
+static __inline__ __attribute__((always_inline)) long _InterlockedOr64(volatile long long * const value, const long long mask)
+{
+	return __sync_fetch_and_or(value, mask);
+}
+#endif
+
 static __inline__ __attribute__((always_inline)) char _InterlockedXor8(volatile char * const value, const char mask)
 {
 	return __sync_fetch_and_xor(value, mask);
@@ -455,6 +469,15 @@ static __inline__ __attribute__((always_inline)) unsigned char _interlockedbitte
 	return retval;
 }
 
+#if defined(_M_AMD64)
+static __inline__ __attribute__((always_inline)) unsigned char _interlockedbittestandreset64(volatile long long * a, const long long b)
+{
+	unsigned char retval;
+	__asm__("lock; btrq %[b], %[a]; setb %b[retval]" : [retval] "=r" (retval), [a] "=m" (a) : [b] "Ir" (b) : "memory");
+	return retval;
+}
+#endif
+
 static __inline__ __attribute__((always_inline)) unsigned char _interlockedbittestandset(volatile long * a, const long b)
 {
 	unsigned char retval;
@@ -462,6 +485,14 @@ static __inline__ __attribute__((always_inline)) unsigned char _interlockedbitte
 	return retval;
 }
 
+#if defined(_M_AMD64)
+static __inline__ __attribute__((always_inline)) unsigned char _interlockedbittestandset64(volatile long long * a, const long long b)
+{
+	unsigned char retval;
+	__asm__("lock; btsq %[b], %[a]; setc %b[retval]" : [retval] "=r" (retval), [a] "=m" (a) : [b] "Ir" (b) : "memory");
+	return retval;
+}
+#endif
 
 /*** String operations ***/
 /* NOTE: we don't set a memory clobber in the __stosX functions because Visual C++ doesn't */
@@ -525,7 +556,98 @@ static __inline__ __attribute__((always_inline)) void __movsd(unsigned long * De
 	);
 }
 
+#if defined(_M_AMD64)
+/*** GS segment addressing ***/
 
+static __inline__ __attribute__((always_inline)) void __writegsbyte(const unsigned long Offset, const unsigned char Data)
+{
+	__asm__("movb %b[Data], %%gs:%a[Offset]" : : [Offset] "ir" (Offset), [Data] "iq" (Data));
+}
+
+static __inline__ __attribute__((always_inline)) void __writegsword(const unsigned long Offset, const unsigned short Data)
+{
+	__asm__("movw %w[Data], %%gs:%a[Offset]" : : [Offset] "ir" (Offset), [Data] "iq" (Data));
+}
+
+static __inline__ __attribute__((always_inline)) void __writegsdword(const unsigned long Offset, const unsigned long Data)
+{
+	__asm__("movl %k[Data], %%gs:%a[Offset]" : : [Offset] "ir" (Offset), [Data] "iq" (Data));
+}
+
+static __inline__ __attribute__((always_inline)) void __writegsqword(const unsigned long Offset, const unsigned __int64 Data)
+{
+	__asm__("movq %q[Data], %%gs:%a[Offset]" : : [Offset] "ir" (Offset), [Data] "iq" (Data));
+}
+
+static __inline__ __attribute__((always_inline)) unsigned char __readgsbyte(const unsigned long Offset)
+{
+	unsigned char value;
+	__asm__("movb %%gs:%a[Offset], %b[value]" : [value] "=q" (value) : [Offset] "irm" (Offset));
+	return value;
+}
+
+static __inline__ __attribute__((always_inline)) unsigned short __readgsword(const unsigned long Offset)
+{
+	unsigned short value;
+	__asm__("movw %%gs:%a[Offset], %w[value]" : [value] "=q" (value) : [Offset] "irm" (Offset));
+	return value;
+}
+
+static __inline__ __attribute__((always_inline)) unsigned long __readgsdword(const unsigned long Offset)
+{
+	unsigned long value;
+	__asm__("movl %%gs:%a[Offset], %k[value]" : [value] "=q" (value) : [Offset] "irm" (Offset));
+	return value;
+}
+
+static __inline__ __attribute__((always_inline)) unsigned __int64 __readgsqword(const unsigned long Offset)
+{
+	unsigned long value;
+	__asm__("movq %%gs:%a[Offset], %q[value]" : [value] "=q" (value) : [Offset] "irm" (Offset));
+	return value;
+}
+
+static __inline__ __attribute__((always_inline)) void __incgsbyte(const unsigned long Offset)
+{
+	__asm__("incb %%gs:%a[Offset]" : : [Offset] "ir" (Offset));
+}
+
+static __inline__ __attribute__((always_inline)) void __incgsword(const unsigned long Offset)
+{
+	__asm__("incw %%gs:%a[Offset]" : : [Offset] "ir" (Offset));
+}
+
+static __inline__ __attribute__((always_inline)) void __incgsdword(const unsigned long Offset)
+{
+	__asm__("incl %%gs:%a[Offset]" : : [Offset] "ir" (Offset));
+}
+
+/* NOTE: the bizarre implementation of __addgsxxx mimics the broken Visual C++ behavior */
+static __inline__ __attribute__((always_inline)) void __addgsbyte(const unsigned long Offset, const unsigned char Data)
+{
+	if(!__builtin_constant_p(Offset))
+		__asm__("addb %k[Offset], %%gs:%a[Offset]" : : [Offset] "r" (Offset));
+	else
+		__asm__("addb %b[Data], %%gs:%a[Offset]" : : [Offset] "ir" (Offset), [Data] "iq" (Data));
+}
+
+static __inline__ __attribute__((always_inline)) void __addgsword(const unsigned long Offset, const unsigned short Data)
+{
+	if(!__builtin_constant_p(Offset))
+		__asm__("addw %k[Offset], %%gs:%a[Offset]" : : [Offset] "r" (Offset));
+	else
+		__asm__("addw %w[Data], %%gs:%a[Offset]" : : [Offset] "ir" (Offset), [Data] "iq" (Data));
+}
+
+static __inline__ __attribute__((always_inline)) void __addgsdword(const unsigned long Offset, const unsigned int Data)
+{
+	if(!__builtin_constant_p(Offset))
+		__asm__("addl %k[Offset], %%gs:%a[Offset]" : : [Offset] "r" (Offset));
+	else
+		__asm__("addl %k[Data], %%gs:%a[Offset]" : : [Offset] "ir" (Offset), [Data] "iq" (Data));
+}
+
+#else
 /*** FS segment addressing ***/
 static __inline__ __attribute__((always_inline)) void __writefsbyte(const unsigned long Offset, const unsigned char Data)
 {
@@ -602,6 +724,7 @@ static __inline__ __attribute__((always_inline)) void __addfsdword(const unsigne
 	else
 		__asm__("addl %k[Data], %%fs:%a[Offset]" : : [Offset] "ir" (Offset), [Data] "iq" (Data));
 }
+#endif
 
 
 /*** Bit manipulation ***/

reactos/include/psdk/winbase.h

@@ -1081,12 +1081,12 @@ typedef RTL_CONDITION_VARIABLE CONDITION_VARIABLE, *PCONDITION_VARIABLE;
 typedef DWORD(WINAPI *LPPROGRESS_ROUTINE)(LARGE_INTEGER,LARGE_INTEGER,LARGE_INTEGER,LARGE_INTEGER,DWORD,DWORD,HANDLE,HANDLE,LPVOID);
 typedef void(WINAPI *LPFIBER_START_ROUTINE)(PVOID);
 typedef VOID (WINAPI *PFLS_CALLBACK_FUNCTION)(PVOID);
-typedef BOOL(CALLBACK *ENUMRESLANGPROCA)(HMODULE,LPCSTR,LPCSTR,WORD,LONG);
+typedef BOOL(CALLBACK *ENUMRESLANGPROCA)(HMODULE,LPCSTR,LPCSTR,WORD,LONG_PTR);
-typedef BOOL(CALLBACK *ENUMRESLANGPROCW)(HMODULE,LPCWSTR,LPCWSTR,WORD,LONG);
+typedef BOOL(CALLBACK *ENUMRESLANGPROCW)(HMODULE,LPCWSTR,LPCWSTR,WORD,LONG_PTR);
-typedef BOOL(CALLBACK *ENUMRESNAMEPROCA)(HMODULE,LPCSTR,LPSTR,LONG);
+typedef BOOL(CALLBACK *ENUMRESNAMEPROCA)(HMODULE,LPCSTR,LPSTR,LONG_PTR);
-typedef BOOL(CALLBACK *ENUMRESNAMEPROCW)(HMODULE,LPCWSTR,LPWSTR,LONG);
+typedef BOOL(CALLBACK *ENUMRESNAMEPROCW)(HMODULE,LPCWSTR,LPWSTR,LONG_PTR);
-typedef BOOL(CALLBACK *ENUMRESTYPEPROCA)(HMODULE,LPSTR,LONG);
+typedef BOOL(CALLBACK *ENUMRESTYPEPROCA)(HMODULE,LPSTR,LONG_PTR);
-typedef BOOL(CALLBACK *ENUMRESTYPEPROCW)(HMODULE,LPWSTR,LONG);
+typedef BOOL(CALLBACK *ENUMRESTYPEPROCW)(HMODULE,LPWSTR,LONG_PTR);
 typedef void(CALLBACK *LPOVERLAPPED_COMPLETION_ROUTINE)(DWORD,DWORD,LPOVERLAPPED);
 typedef LONG(CALLBACK *PTOP_LEVEL_EXCEPTION_FILTER)(LPEXCEPTION_POINTERS);
 typedef PTOP_LEVEL_EXCEPTION_FILTER LPTOP_LEVEL_EXCEPTION_FILTER;
@@ -1707,14 +1707,23 @@ VOID WINAPI InitializeSRWLock(PSRWLOCK);
 #ifndef __INTERLOCKED_DECLARED
 #define __INTERLOCKED_DECLARED
 LONG WINAPI InterlockedCompareExchange(IN OUT LONG volatile *,LONG,LONG);
-/* PVOID WINAPI InterlockedCompareExchangePointer(PVOID*,PVOID,PVOID); */
-#define InterlockedCompareExchangePointer(d,e,c) \
-    (PVOID)InterlockedCompareExchange((LPLONG)(d),(LONG)(e),(LONG)(c))
 LONG WINAPI InterlockedDecrement(IN OUT LONG volatile *);
 LONG WINAPI InterlockedExchange(IN OUT LONG volatile *,LONG);
-/* PVOID WINAPI InterlockedExchangePointer(PVOID*,PVOID); */
+#if defined(_WIN64)
-#define InterlockedExchangePointer(t,v) \
+ /* PVOID WINAPI InterlockedExchangePointer(PVOID*,PVOID); */
+ #define InterlockedExchangePointer(t,v) \
+    (PVOID)InterlockedExchange64((LONGLONG*)(t),(LONGLONG)(v))
+ /* PVOID WINAPI InterlockedCompareExchangePointer(PVOID*,PVOID,PVOID); */
+ #define InterlockedCompareExchangePointer(d,e,c) \
+    (PVOID)InterlockedCompareExchange64((LONGLONG*)(d),(LONGLONG)(e),(LONGLONG)(c))
+#else
+ /* PVOID WINAPI InterlockedExchangePointer(PVOID*,PVOID); */
+ #define InterlockedExchangePointer(t,v) \
     (PVOID)InterlockedExchange((LPLONG)(t),(LONG)(v))
+ /* PVOID WINAPI InterlockedCompareExchangePointer(PVOID*,PVOID,PVOID); */
+ #define InterlockedCompareExchangePointer(d,e,c) \
+    (PVOID)InterlockedCompareExchange((LPLONG)(d),(LONG)(e),(LONG)(c))
+#endif
 LONG WINAPI InterlockedExchangeAdd(IN OUT LONG volatile *,LONG);
 #if (_WIN32_WINNT >= 0x0501)
 PSLIST_ENTRY WINAPI InterlockedFlushSList(PSLIST_HEADER);

reactos/include/psdk/winnt.h

@@ -1350,7 +1350,7 @@ typedef enum
 #define IMAGE_DLLCHARACTERISTICS_NO_BIND 0x0800
 #define IMAGE_DLLCHARACTERISTICS_WDM_DRIVER 0x2000
 #define IMAGE_DLLCHARACTERISTICS_TERMINAL_SERVER_AWARE 0x8000
-#define IMAGE_FIRST_SECTION(h) ((PIMAGE_SECTION_HEADER) ((DWORD)h+FIELD_OFFSET(IMAGE_NT_HEADERS,OptionalHeader)+((PIMAGE_NT_HEADERS)(h))->FileHeader.SizeOfOptionalHeader))
+#define IMAGE_FIRST_SECTION(h) ((PIMAGE_SECTION_HEADER) ((DWORD_PTR)h+FIELD_OFFSET(IMAGE_NT_HEADERS,OptionalHeader)+((PIMAGE_NT_HEADERS)(h))->FileHeader.SizeOfOptionalHeader))
 #define IMAGE_DIRECTORY_ENTRY_EXPORT	0
 #define IMAGE_DIRECTORY_ENTRY_IMPORT	1
 #define IMAGE_DIRECTORY_ENTRY_RESOURCE	2
@@ -4090,6 +4090,11 @@ static __inline__ PVOID GetCurrentFiber(void)
     );
     return ret;
 }
+#elif defined (_M_AMD64)
+FORCEINLINE PVOID GetCurrentFiber(VOID)
+{
+    return (PVOID)__readgsqword(FIELD_OFFSET(NT_TIB, FiberData));
+}
 #elif defined (_M_ARM)
     PVOID WINAPI GetCurrentFiber(VOID);
 #else
@@ -4137,6 +4142,11 @@ static __inline__ struct _TEB * NtCurrentTeb(void)
 #define KIRQL ULONG // Hack!
 #include <armddk.h>
 
+#elif defined (_M_AMD64)
+FORCEINLINE struct _TEB * NtCurrentTeb(VOID)
+{
+    return __readgsqword(FIELD_OFFSET(NT_TIB, Self));
+}
 #else
 static __inline__ struct _TEB * NtCurrentTeb(void)
 {
@@ -4267,6 +4277,8 @@ BitScanReverse(OUT ULONG *Index,
 
 #if defined(_M_IX86)
 #define YieldProcessor() __asm__ __volatile__("pause");
+#elif defined (_M_AMD64)
+#define YieldProcessor() __asm__ __volatile__("pause");
 #elif defined(_M_PPC)
 #define YieldProcessor() __asm__ __volatile__("nop");
 #elif defined(_M_MIPS)
@@ -4282,6 +4294,19 @@ BitScanReverse(OUT ULONG *Index,
 
 #define InterlockedExchangeAddSizeT(a, b) InterlockedExchangeAdd64((LONG64 *)a, b)
 
+#define InterlockedAnd _InterlockedAnd
+#define InterlockedExchange _InterlockedExchange
+#define InterlockedOr _InterlockedOr
+
+#define InterlockedAnd64 _InterlockedAnd64
+#define InterlockedOr64 _InterlockedOr64
+
+#define InterlockedBitTestAndSet _interlockedbittestandset
+#define InterlockedBitTestAndSet64 _interlockedbittestandset64
+#define InterlockedBitTestAndReset _interlockedbittestandreset
+#define InterlockedBitTestAndReset64 _interlockedbittestandreset64
+
+
 #endif
 
 #else

reactos/include/reactos/rosldr.h

@@ -17,34 +17,34 @@
 
 typedef struct _LOADER_MODULE
 {
-    ULONG ModStart;
+    ULONG_PTR ModStart;
-    ULONG ModEnd;
+    ULONG_PTR ModEnd;
-    ULONG String;
+    ULONG_PTR String;
-    ULONG Reserved;
+    ULONG_PTR Reserved;
 } LOADER_MODULE, *PLOADER_MODULE;
 
 typedef struct _ROS_LOADER_PARAMETER_BLOCK
 {
     ULONG Flags;
-    ULONG MemLower;
+    ULONG_PTR MemLower;
-    ULONG MemHigher;
+    ULONG_PTR MemHigher;
     ULONG BootDevice;
     PCHAR CommandLine;
     ULONG ModsCount;
     PLOADER_MODULE ModsAddr;
     UCHAR Syms[12];
-    ULONG MmapLength;
+    SIZE_T MmapLength;
-    ULONG MmapAddr;
+    ULONG_PTR MmapAddr;
-    ULONG RdLength;
+    SIZE_T RdLength;
-    ULONG RdAddr;
+    ULONG_PTR RdAddr;
     ULONG DrivesCount;
     PARC_DISK_SIGNATURE DrivesAddr;
     ULONG ConfigTable;
     ULONG BootLoaderName;
-    ULONG PageDirectoryStart;
+    ULONG_PTR PageDirectoryStart;
-    ULONG PageDirectoryEnd;
+    ULONG_PTR PageDirectoryEnd;
-    ULONG KernelBase;
+    ULONG_PTR KernelBase;
-    ULONG ArchExtra;
+    ULONG_PTR ArchExtra;
 } ROS_LOADER_PARAMETER_BLOCK, *PROS_LOADER_PARAMETER_BLOCK;
 
 extern BOOLEAN AcpiTableDetected;

reactos/include/reactos/wine/list.h

@@ -224,7 +224,12 @@ static inline void list_move_head( struct list *dst, struct list *src )
 #define LIST_INIT(list)  { &(list), &(list) }
 
 /* get pointer to object containing list element */
+#ifdef _WIN64
+#define LIST_ENTRY(elem, type, field) \
+    ((type *)((char *)(elem) - (unsigned long long)(&((type *)0)->field)))
+#else
 #define LIST_ENTRY(elem, type, field) \
     ((type *)((char *)(elem) - (unsigned long)(&((type *)0)->field)))
+#endif
 
 #endif  /* __WINE_SERVER_LIST_H */