From 0abf169695caa6dc71401aa7923a52d5577e4e73 Mon Sep 17 00:00:00 2001
From: Art Yerkes <art.yerkes@gmail.com>
Date: Sat, 6 Oct 2007 07:53:20 +0000
Subject: [PATCH] All remaining changes from the PPC branch.  Not well tested
 yet.  Many things are indeed still stubs or WIP code.

Some people have been interested in helping out from some time and I'm sorry
I haven't been able to do this merge finally for a while.

svn path=/trunk/; revision=29407
---
 reactos/Makefile                              |    2 +-
 reactos/ReactOS-i386.rbuild                   |    2 +
 reactos/ReactOS-ppc.rbuild                    |   46 +-
 .../boot/freeldr/freeldr/arch/powerpc/boot.s  |   10 +-
 .../boot/freeldr/freeldr/arch/powerpc/mach.c  |    8 +-
 reactos/boot/freeldr/freeldr/freeldr.rbuild   |    1 +
 reactos/boot/freeldr/freeldr/fs/fat.c         |    2 +-
 reactos/boot/freeldr/freeldr/include/arch.h   |    6 +
 reactos/config-ppc.template.rbuild            |    4 +
 reactos/include/ddk/winddk.h                  |   29 +
 reactos/include/psdk/intrin_ppc.h             |  214 +-
 reactos/include/psdk/winnt.h                  |   14 +-
 reactos/lib/lib.rbuild                        |    3 +
 reactos/lib/pseh/powerpc/framebased.S         |   82 +
 reactos/lib/pseh/pseh.rbuild                  |    5 +
 reactos/lib/rtl/powerpc/rtlmem.s              |  105 +
 reactos/lib/rtl/powerpc/rtlswap.s             |   41 +
 reactos/lib/rtl/rtl.rbuild                    |    2 +
 .../sdk/libcntpr/except/powerpc/chkstk_asm.s  |   23 +
 reactos/lib/sdk/libcntpr/except/powerpc/seh.s |   75 +
 reactos/lib/sdk/libcntpr/libcntpr.rbuild      |    7 +-
 reactos/ntoskrnl/config/powerpc/cmhardwr.c    |  834 ++++++++
 reactos/ntoskrnl/ex/powerpc/fastinterlck.c    |  262 +++
 reactos/ntoskrnl/ex/powerpc/ioport.s          |  171 ++
 reactos/ntoskrnl/ex/sysinfo.c                 |    2 +-
 .../ntoskrnl/include/internal/i386/intrin_i.h |    3 +
 reactos/ntoskrnl/include/internal/kd.h        |    5 +
 reactos/ntoskrnl/include/internal/ke_x.h      |   10 +-
 reactos/ntoskrnl/include/internal/ntoskrnl.h  |    4 +-
 .../include/internal/powerpc/intrin_i.h       |    2 +
 .../ntoskrnl/include/internal/powerpc/ke.h    |   61 +-
 reactos/ntoskrnl/kd/kdmain.c                  |    8 +
 .../ntoskrnl/kd/wrappers/gdbstub_powerpc.c    | 1714 +++++++++++++++++
 reactos/ntoskrnl/ke/bug.c                     |   15 +-
 reactos/ntoskrnl/ke/powerpc/cpu.c             |  277 +++
 reactos/ntoskrnl/ke/powerpc/exp.c             |  114 ++
 reactos/ntoskrnl/ke/powerpc/kiinit.c          |  322 ++++
 reactos/ntoskrnl/ke/powerpc/main_asm.S        |   81 +
 reactos/ntoskrnl/ke/powerpc/ppc_irq.c         |  841 ++++++++
 reactos/ntoskrnl/ke/powerpc/stubs.c           |  234 +++
 reactos/ntoskrnl/ke/powerpc/systimer.c        |   21 +
 reactos/ntoskrnl/ke/profobj.c                 |    4 +
 reactos/ntoskrnl/mm/mm.c                      |    2 +
 reactos/ntoskrnl/mm/pagefile.c                |    2 +
 reactos/ntoskrnl/mm/powerpc/page.c            |  630 ++++++
 reactos/ntoskrnl/mm/powerpc/pfault.c          |   96 +
 reactos/ntoskrnl/ntoskrnl.rbuild              |   37 +-
 .../{ntoskrnl.lnk => ntoskrnl_i386.lnk}       |    0
 reactos/ntoskrnl/ntoskrnl_powerpc.lnk         |   69 +
 reactos/ntoskrnl/ps/debug.c                   |    4 +
 reactos/ntoskrnl/ps/thread.c                  |    3 +-
 reactos/ntoskrnl/rtl/libsupp.c                |    4 +
 reactos/subsystems/win32/win32k/win32k.rbuild |    5 +-
 reactos/tools/ppc.lost+found/bootcd           |    4 +-
 reactos/tools/ppc.lost+found/link-freeldr     |    7 -
 reactos/tools/ppc.lost+found/pmake            |   14 -
 reactos/tools/rbuild/backend/mingw/mingw.cpp  |    3 +-
 .../rbuild/backend/mingw/modulehandler.cpp    |   31 +-
 .../rbuild/backend/mingw/modulehandler.h      |    2 +-
 reactos/tools/tools.mak                       |    4 +-
 60 files changed, 6403 insertions(+), 180 deletions(-)
 create mode 100644 reactos/lib/pseh/powerpc/framebased.S
 create mode 100644 reactos/lib/rtl/powerpc/rtlmem.s
 create mode 100644 reactos/lib/rtl/powerpc/rtlswap.s
 create mode 100644 reactos/lib/sdk/libcntpr/except/powerpc/chkstk_asm.s
 create mode 100644 reactos/lib/sdk/libcntpr/except/powerpc/seh.s
 create mode 100644 reactos/ntoskrnl/config/powerpc/cmhardwr.c
 create mode 100644 reactos/ntoskrnl/ex/powerpc/fastinterlck.c
 create mode 100644 reactos/ntoskrnl/ex/powerpc/ioport.s
 create mode 100644 reactos/ntoskrnl/kd/wrappers/gdbstub_powerpc.c
 create mode 100644 reactos/ntoskrnl/ke/powerpc/cpu.c
 create mode 100644 reactos/ntoskrnl/ke/powerpc/exp.c
 create mode 100644 reactos/ntoskrnl/ke/powerpc/kiinit.c
 create mode 100644 reactos/ntoskrnl/ke/powerpc/main_asm.S
 create mode 100644 reactos/ntoskrnl/ke/powerpc/ppc_irq.c
 create mode 100644 reactos/ntoskrnl/ke/powerpc/stubs.c
 create mode 100644 reactos/ntoskrnl/ke/powerpc/systimer.c
 create mode 100644 reactos/ntoskrnl/mm/powerpc/page.c
 create mode 100644 reactos/ntoskrnl/mm/powerpc/pfault.c
 rename reactos/ntoskrnl/{ntoskrnl.lnk => ntoskrnl_i386.lnk} (100%)
 create mode 100644 reactos/ntoskrnl/ntoskrnl_powerpc.lnk
 delete mode 100755 reactos/tools/ppc.lost+found/link-freeldr
 delete mode 100755 reactos/tools/ppc.lost+found/pmake

diff --git a/reactos/Makefile b/reactos/Makefile
index 89ac3ddbb9d..63d8c4ccc87 100644
--- a/reactos/Makefile
+++ b/reactos/Makefile
@@ -401,7 +401,7 @@ ifeq ($(ARCH),powerpc)
 PREAUTO += $(OFW_INTERFACE_SERVICE_FILES) $(PPCMMU_TARGETS)
 endif
 
-$(ROS_AUTOMAKE): $(RBUILD_TARGET) $(PREAUTO) $(XMLBUILDFILES)
+$(ROS_AUTOMAKE): $(RBUILD_TARGET) $(XMLBUILDFILES) | $(PREAUTO)
 	${mkdir} $(OUTPUT_)media$(SEP)inf 2>$(NUL)
 	$(ECHO_RBUILD)
 	$(Q)$(RBUILD_TARGET) $(RBUILD_FLAGS) $(ROS_RBUILDFLAGS) mingw
diff --git a/reactos/ReactOS-i386.rbuild b/reactos/ReactOS-i386.rbuild
index 1c4acdd35d2..f7fc299b509 100644
--- a/reactos/ReactOS-i386.rbuild
+++ b/reactos/ReactOS-i386.rbuild
@@ -13,6 +13,8 @@
 	<define name="_X86_" />
 	<define name="__i386__" />
 
+	<property name="NTOSKRNL_SHARED" value="-Wl,--file-alignment,0x1000 -Wl,--section-alignment,0x1000 -nostartfiles -shared"/>
+
 	<if property="GDB" value="0">
 		<if property="OPTIMIZE" value="1">
 				<compilerflag>-Os</compilerflag>
diff --git a/reactos/ReactOS-ppc.rbuild b/reactos/ReactOS-ppc.rbuild
index 0a5f712b0af..a0882d399f5 100644
--- a/reactos/ReactOS-ppc.rbuild
+++ b/reactos/ReactOS-ppc.rbuild
@@ -9,27 +9,31 @@
 
 	<xi:include href="ReactOS-generic.rbuild" />
 
-	<property name="OFWLDR_LINKFORMAT" value="-L$(INTERMEDIATE)/lib/ppcmmu -lppcmmu_code -lppcmmu -nostdlib -nostartfiles"/>
+	<property name="OFWLDR_LINKFORMAT" value="-L$(INTERMEDIATE)/lib/ppcmmu -lppcmmu_code -nostdlib -nostartfiles -lgcc -Wl,-e,__start -Wl,-Ttext,0xe00000 -N"/>
+        <property name="NTOSKRNL_SHARED" value="-Wl,--file-alignment,0x1000 -Wl,--section-alignment,0x1000 -nostartfiles"/>
 
-	<define name="_M_PPC" />
-	<define name="_PPC_" />
-	<define name="__PowerPC__" />
-	<define name="_REACTOS_" />
-	<define name="stdcall" empty="true" />
-	<define name="__stdcall__" empty="true" />
-	<define name="fastcall" empty="true" />
-	<define name="cdecl" empty="true" />
-	<define name="__cdecl__" empty="true" />
-	<define name="dllimport" empty="true" />
-	<define name="WORDS_BIGENDIAN" empty="true" />
-	<define name="MB_CUR_MAX">1</define>
-	<define name="_BSDTYPES_DEFINED"/>
-	<compilerflag>-fshort-wchar</compilerflag>
-	<compilerflag>-fsigned-char</compilerflag>
-	<compilerflag>-mfull-toc</compilerflag>
-	<compilerflag>-meabi</compilerflag>
-	<compilerflag>-O2</compilerflag>
-	<compilerflag>-Wno-strict-aliasing</compilerflag>
-	<compilerflag>-Wno-trampolines</compilerflag>
+  <define name="_M_PPC" />
+  <define name="_PPC_" />
+  <define name="__PowerPC__" />
+  <define name="_REACTOS_" />
+  <define name="stdcall" empty="true" />	
+  <define name="__stdcall__" empty="true" />
+  <define name="fastcall" empty="true" />
+  <define name="cdecl" empty="true" />
+  <define name="__cdecl__" empty="true" />
+  <define name="dllimport" empty="true" />
+  <define name="WORDS_BIGENDIAN" empty="true" />
+  <define name="__MSVCRT__" empty="true" />
+  <define name="__NO_CTYPE_INLINES" />
+  <define name="__DECLSPEC_SUPPORTED" />
+  <define name="__MINGW_IMPORT">extern</define>
+  <define name="_CRTIMP" empty="true" />
+  <define name="'__declspec(x)'" empty="true" />
+  <compilerflag>-fshort-wchar</compilerflag>
+  <compilerflag>-fsigned-char</compilerflag>
+  <compilerflag>-mfull-toc</compilerflag>
+  <compilerflag>-meabi</compilerflag>
+  <compilerflag>-O2</compilerflag>
+  <compilerflag>-Wno-strict-aliasing</compilerflag>
 
 </project>
diff --git a/reactos/boot/freeldr/freeldr/arch/powerpc/boot.s b/reactos/boot/freeldr/freeldr/arch/powerpc/boot.s
index 7efff45fb7b..62e0f3cb9d6 100644
--- a/reactos/boot/freeldr/freeldr/arch/powerpc/boot.s
+++ b/reactos/boot/freeldr/freeldr/arch/powerpc/boot.s
@@ -28,10 +28,18 @@ _start:
 	lwz	%r3,ofw_call_addr@l(%r3)
 	cmpw	%r3,%r31 /* Zero? */
 	mr	%r3,%r31
-	beq	bootme
+	beq	initfp
 		
 	lis	%r3,call_ofw@ha
 	addi	%r3,%r3,call_ofw@l
+        b       bootme
+
+initfp:
+        /* Enabling FP at this point won't hurt, and the varargs scheme we're
+         * using now requires it. */
+        mfmsr   %r0
+        ori     %r0,%r0,8192
+        mtmsr   %r0
 
 bootme:	
 	blr
diff --git a/reactos/boot/freeldr/freeldr/arch/powerpc/mach.c b/reactos/boot/freeldr/freeldr/arch/powerpc/mach.c
index de937c04bd0..64882187b55 100644
--- a/reactos/boot/freeldr/freeldr/arch/powerpc/mach.c
+++ b/reactos/boot/freeldr/freeldr/arch/powerpc/mach.c
@@ -591,9 +591,11 @@ void MachInit(const char *CmdLine) {
     }
 
     if( strlen(BootPart) == 0 ) {
-	len = ofw_getprop(chosen_package, "bootpath", 
-			  BootPath, sizeof(BootPath));
-	
+	if (ofproxy)
+            len = ofw_getprop(chosen_package, "bootpath", 
+                              BootPath, sizeof(BootPath));
+	else
+            len = 0;
 	if( len < 0 ) len = 0;
 	BootPath[len] = 0;
 	printf( "Boot Path: %s\n", BootPath );
diff --git a/reactos/boot/freeldr/freeldr/freeldr.rbuild b/reactos/boot/freeldr/freeldr/freeldr.rbuild
index 5e129deeae9..e4d4dbfeed9 100644
--- a/reactos/boot/freeldr/freeldr/freeldr.rbuild
+++ b/reactos/boot/freeldr/freeldr/freeldr.rbuild
@@ -26,6 +26,7 @@
 			<library>cmlib</library>
 			<library>rtl</library>
 			<library>libcntpr</library>
+			<library>ppcmmu</library>
 		</module>
 	</if>
 </group>
diff --git a/reactos/boot/freeldr/freeldr/fs/fat.c b/reactos/boot/freeldr/freeldr/fs/fat.c
index 49156110a4e..74528fb3a2c 100644
--- a/reactos/boot/freeldr/freeldr/fs/fat.c
+++ b/reactos/boot/freeldr/freeldr/fs/fat.c
@@ -242,7 +242,7 @@ BOOLEAN FatOpenVolume(ULONG DriveNumber, ULONG VolumeStartSector, ULONG Partitio
 	//
 	// Check the boot sector magic
 	//
-	if (! ISFATX(FatType) && SWAPW(FatVolumeBootSector->BootSectorMagic) != 0xaa55)
+	if (! ISFATX(FatType) && FatVolumeBootSector->BootSectorMagic != 0xaa55)
 	{
 		sprintf(ErrMsg, "Invalid boot sector magic on drive 0x%x (expected 0xaa55 found 0x%x)",
 		        DriveNumber, FatVolumeBootSector->BootSectorMagic);
diff --git a/reactos/boot/freeldr/freeldr/include/arch.h b/reactos/boot/freeldr/freeldr/include/arch.h
index 037f1cf4310..c92c4c91e56 100644
--- a/reactos/boot/freeldr/freeldr/include/arch.h
+++ b/reactos/boot/freeldr/freeldr/include/arch.h
@@ -34,11 +34,17 @@
 #define STACK16ADDR	0x7000	/* The 16-bit stack top will be at 0000:7000 */
 #define STACK32ADDR	0x78000	/* The 32-bit stack top will be at 7000:8000, or 0x78000 */
 
+#ifdef _M_IX86
 #define BIOSCALLBUFFER		0x78000	/* Buffer to store temporary data for any Int386() call */
 #define BIOSCALLBUFSEGMENT	0x7800	/* Buffer to store temporary data for any Int386() call */
 #define BIOSCALLBUFOFFSET	0x0000	/* Buffer to store temporary data for any Int386() call */
 #define FILESYSBUFFER		0x80000	/* Buffer to store file system data (e.g. cluster buffer for FAT) */
 #define DISKREADBUFFER		0x90000	/* Buffer to store data read in from the disk via the BIOS */
+#elif defined(_M_PPC)
+extern PVOID FsStaticBufferDisk, FsStaticBufferData;
+#define DISKREADBUFFER		FsStaticBufferDisk
+#define FILESYSBUFFER           FsStaticBufferData
+#endif
 
 /* Makes "x" a global variable or label */
 #define EXTERN(x)	.global x; x:
diff --git a/reactos/config-ppc.template.rbuild b/reactos/config-ppc.template.rbuild
index 36f36b8690b..9eca1ed4696 100644
--- a/reactos/config-ppc.template.rbuild
+++ b/reactos/config-ppc.template.rbuild
@@ -35,6 +35,10 @@
 -->
 <property name="MP" value="0" />
 
+<!--
+        New style kernel debugger 
+-->
+<property name="_WINKD_" value="0" />
 
 <!--
 	Whether to compile in the integrated kernel debugger.
diff --git a/reactos/include/ddk/winddk.h b/reactos/include/ddk/winddk.h
index 6f21b539305..9c2a1fdfcef 100644
--- a/reactos/include/ddk/winddk.h
+++ b/reactos/include/ddk/winddk.h
@@ -9327,6 +9327,35 @@ KeRaiseIrqlToSynchLevel(
 #define KeLowerIrql(a) KfLowerIrql(a)
 #define KeRaiseIrql(a,b) *(b) = KfRaiseIrql(a)
 
+#elif defined(__PowerPC__)
+
+NTHALAPI
+VOID
+FASTCALL
+KfLowerIrql(
+  IN KIRQL  NewIrql);
+
+NTHALAPI
+KIRQL
+FASTCALL
+KfRaiseIrql(
+  IN KIRQL  NewIrql);
+
+NTHALAPI
+KIRQL
+DDKAPI
+KeRaiseIrqlToDpcLevel(
+  VOID);
+
+NTHALAPI
+KIRQL
+DDKAPI
+KeRaiseIrqlToSynchLevel(
+    VOID);
+
+#define KeLowerIrql(a) KfLowerIrql(a)
+#define KeRaiseIrql(a,b) *(b) = KfRaiseIrql(a)
+
 #else
 
 NTKERNELAPI
diff --git a/reactos/include/psdk/intrin_ppc.h b/reactos/include/psdk/intrin_ppc.h
index ac7e921e5ad..55327e66ce1 100644
--- a/reactos/include/psdk/intrin_ppc.h
+++ b/reactos/include/psdk/intrin_ppc.h
@@ -28,6 +28,9 @@
 #ifndef KJK_INTRIN_PPC_H_
 #define KJK_INTRIN_PPC_H_
 
+//#define PPC_QUAL static __inline__ __attribute__((always_inline))
+#define PPC_QUAL extern __inline__
+
 #ifndef __GNUC__
 #error Unsupported compiler
 #endif
@@ -50,98 +53,98 @@
 
 #if (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__) > 40100
 
-static __inline__ __attribute__((always_inline)) char _InterlockedCompareExchange8(volatile char * const Destination, const char Exchange, const char Comperand)
+PPC_QUAL char _InterlockedCompareExchange8(volatile char * const Destination, const char Exchange, const char Comperand)
 {
 	return __sync_val_compare_and_swap(Destination, Comperand, Exchange);
 }
 
-static __inline__ __attribute__((always_inline)) short _InterlockedCompareExchange16(volatile short * const Destination, const short Exchange, const short Comperand)
+PPC_QUAL short _InterlockedCompareExchange16(volatile short * const Destination, const short Exchange, const short Comperand)
 {
 	return __sync_val_compare_and_swap(Destination, Comperand, Exchange);
 }
 
-static __inline__ __attribute__((always_inline)) long _InterlockedCompareExchange(volatile long * const Destination, const long Exchange, const long Comperand)
+PPC_QUAL long _InterlockedCompareExchange(volatile long * const Destination, const long Exchange, const long Comperand)
 {
 	return __sync_val_compare_and_swap(Destination, Comperand, Exchange);
 }
 
-static __inline__ __attribute__((always_inline)) long long _InterlockedCompareExchange64(volatile long long * const Destination, const long long Exchange, const long long Comperand)
+PPC_QUAL long long _InterlockedCompareExchange64(volatile long long * const Destination, const long long Exchange, const long long Comperand)
 {
 	return __sync_val_compare_and_swap(Destination, Comperand, Exchange);
 }
 
-static __inline__ __attribute__((always_inline)) void * _InterlockedCompareExchangePointer(void * volatile * const Destination, void * const Exchange, void * const Comperand)
+PPC_QUAL void * _InterlockedCompareExchangePointer(void * volatile * const Destination, void * const Exchange, void * const Comperand)
 {
 	return __sync_val_compare_and_swap(Destination, Comperand, Exchange);
 }
 
-static __inline__ __attribute__((always_inline)) long _InterlockedExchange(volatile long * const Target, const long Value)
+PPC_QUAL long _InterlockedExchange(volatile long * const Target, const long Value)
 {
 	/* NOTE: __sync_lock_test_and_set would be an acquire barrier, so we force a full barrier */
 	__sync_synchronize();
 	return __sync_lock_test_and_set(Target, Value);
 }
 
-static __inline__ __attribute__((always_inline)) void * _InterlockedExchangePointer(void * volatile * const Target, void * const Value)
+PPC_QUAL void * _InterlockedExchangePointer(void * volatile * const Target, void * const Value)
 {
 	/* NOTE: ditto */
 	__sync_synchronize();
 	return __sync_lock_test_and_set(Target, Value);
 }
 
-static __inline__ __attribute__((always_inline)) long _InterlockedExchangeAdd(volatile long * const Addend, const long Value)
+PPC_QUAL long _InterlockedExchangeAdd(volatile long * const Addend, const long Value)
 {
 	return __sync_fetch_and_add(Addend, Value);
 }
 
-static __inline__ __attribute__((always_inline)) char _InterlockedAnd8(volatile char * const value, const char mask)
+PPC_QUAL char _InterlockedAnd8(volatile char * const value, const char mask)
 {
 	return __sync_fetch_and_and(value, mask);
 }
 
-static __inline__ __attribute__((always_inline)) short _InterlockedAnd16(volatile short * const value, const short mask)
+PPC_QUAL short _InterlockedAnd16(volatile short * const value, const short mask)
 {
 	return __sync_fetch_and_and(value, mask);
 }
 
-static __inline__ __attribute__((always_inline)) long _InterlockedAnd(volatile long * const value, const long mask)
+PPC_QUAL long _InterlockedAnd(volatile long * const value, const long mask)
 {
 	return __sync_fetch_and_and(value, mask);
 }
 
-static __inline__ __attribute__((always_inline)) char _InterlockedOr8(volatile char * const value, const char mask)
+PPC_QUAL char _InterlockedOr8(volatile char * const value, const char mask)
 {
 	return __sync_fetch_and_or(value, mask);
 }
 
-static __inline__ __attribute__((always_inline)) short _InterlockedOr16(volatile short * const value, const short mask)
+PPC_QUAL short _InterlockedOr16(volatile short * const value, const short mask)
 {
 	return __sync_fetch_and_or(value, mask);
 }
 
-static __inline__ __attribute__((always_inline)) long _InterlockedOr(volatile long * const value, const long mask)
+PPC_QUAL long _InterlockedOr(volatile long * const value, const long mask)
 {
 	return __sync_fetch_and_or(value, mask);
 }
 
-static __inline__ __attribute__((always_inline)) char _InterlockedXor8(volatile char * const value, const char mask)
+PPC_QUAL char _InterlockedXor8(volatile char * const value, const char mask)
 {
 	return __sync_fetch_and_xor(value, mask);
 }
 
-static __inline__ __attribute__((always_inline)) short _InterlockedXor16(volatile short * const value, const short mask)
+PPC_QUAL short _InterlockedXor16(volatile short * const value, const short mask)
 {
 	return __sync_fetch_and_xor(value, mask);
 }
 
-static __inline__ __attribute__((always_inline)) long _InterlockedXor(volatile long * const value, const long mask)
+PPC_QUAL long _InterlockedXor(volatile long * const value, const long mask)
 {
 	return __sync_fetch_and_xor(value, mask);
 }
 
 #else
 
-static __inline__ __attribute__((always_inline)) char _InterlockedCompareExchange8(volatile char * const Destination, const char Exchange, const char Comperand)
+PPC_QUAL char _InterlockedCompareExchange8(volatile char * const Destination, const char Exchange, const char Comperand)
 {
 	char retval = Comperand;
 	__asm__ __volatile__ (
@@ -158,7 +161,7 @@ static __inline__ __attribute__((always_inline)) char _InterlockedCompareExchang
 	return retval;
 }
 
-static __inline__ __attribute__((always_inline)) short _InterlockedCompareExchange16(volatile short * const Destination, const short Exchange, const short Comperand)
+PPC_QUAL short _InterlockedCompareExchange16(volatile short * const Destination, const short Exchange, const short Comperand)
 {
 	short retval = Comperand;
 	__asm__ __volatile__ (
@@ -169,13 +172,30 @@ static __inline__ __attribute__((always_inline)) short _InterlockedCompareExchan
 	    "   sthcx.  %3,0,%1\n"
 	    "   bne-    1b\n"
 	    "2: isync"
-	    : "=b" (retval)
-	    : "b" (Destination), "r" (Comperand), "r" (Exchange)
-	    : "cr0", "memory");
+	    : "=r" (retval)
+	    : "r" (Destination), "r" (Comperand), "r" (Exchange)
+	    : "memory");
 	return retval;
 }
 
-static __inline__ __attribute__((always_inline)) long long _InterlockedCompareExchange64(volatile long long * const Destination, const long long Exchange, const long long Comperand)
+PPC_QUAL long _InterlockedCompareExchange(volatile long * const Destination, const long Exchange, const long Comperand)
+{
+	short retval = Comperand;
+	__asm__ __volatile__ (
+	    "sync\n"
+	    "1: lwarx   %0,0,%1\n"
+	    "   subf.   %0,%2,%0\n"
+	    "   bne     2f\n"
+	    "   stwcx.  %3,0,%1\n"
+	    "   bne-    1b\n"
+	    "2: isync"
+	    : "=r" (retval)
+	    : "r" (Destination), "r" (Comperand), "r" (Exchange)
+	    : "memory");
+	return retval;
+}
+
+PPC_QUAL long long _InterlockedCompareExchange64(volatile long long * const Destination, const long long Exchange, const long long Comperand)
 {
 	unsigned long lo32Retval = (unsigned long)((Comperand >>  0) & 0xFFFFFFFF);
 	long hi32Retval = (unsigned long)((Comperand >> 32) & 0xFFFFFFFF);
@@ -209,13 +229,13 @@ static __inline__ __attribute__((always_inline)) long long _InterlockedCompareEx
 	}
 }
 
-static __inline__ __attribute__((always_inline)) void * _InterlockedCompareExchangePointer(void * volatile * const Destination, void * const Exchange, void * const Comperand)
+PPC_QUAL void * _InterlockedCompareExchangePointer(void * volatile * const Destination, void * const Exchange, void * const Comperand)
 {
     return (void *)_InterlockedCompareExchange
 	((long *)Destination, (long) Exchange, (long) Comperand);
 }
 
-static __inline__ __attribute__((always_inline)) long _InterlockedExchange(volatile long * const Target, const long Value)
+PPC_QUAL long _InterlockedExchange(volatile long * const Target, const long Value)
 {
         long retval;
 	__asm__ __volatile__ (
@@ -229,7 +249,7 @@ static __inline__ __attribute__((always_inline)) long _InterlockedExchange(volat
 	return retval;
 }
 
-static __inline__ __attribute__((always_inline)) void * _InterlockedExchangePointer(void * volatile * const Target, void * const Value)
+PPC_QUAL void * _InterlockedExchangePointer(void * volatile * const Target, void * const Value)
 {
         void * retval;
 	__asm__ __volatile__ (
@@ -243,7 +263,7 @@ static __inline__ __attribute__((always_inline)) void * _InterlockedExchangePoin
 	return retval;
 }
 
-static __inline__ __attribute__((always_inline)) long _InterlockedExchangeAdd(volatile long * const Addend, const long Value)
+PPC_QUAL long _InterlockedExchangeAdd(volatile long * const Addend, const long Value)
 {
         long x;
 	long y = *Addend;
@@ -259,7 +279,7 @@ static __inline__ __attribute__((always_inline)) long _InterlockedExchangeAdd(vo
 	return y;
 }
 
-static __inline__ __attribute__((always_inline)) char _InterlockedAnd8(volatile char * const value, const char mask)
+PPC_QUAL char _InterlockedAnd8(volatile char * const value, const char mask)
 {
 	char x;
 	char y;
@@ -276,7 +296,7 @@ static __inline__ __attribute__((always_inline)) char _InterlockedAnd8(volatile
 	return y;
 }
 
-static __inline__ __attribute__((always_inline)) short _InterlockedAnd16(volatile short * const value, const short mask)
+PPC_QUAL short _InterlockedAnd16(volatile short * const value, const short mask)
 {
 	short x;
 	short y;
@@ -293,7 +313,7 @@ static __inline__ __attribute__((always_inline)) short _InterlockedAnd16(volatil
 	return y;
 }
 
-static __inline__ __attribute__((always_inline)) long _InterlockedAnd(volatile long * const value, const long mask)
+PPC_QUAL long _InterlockedAnd(volatile long * const value, const long mask)
 {
 	long x;
 	long y;
@@ -310,7 +330,7 @@ static __inline__ __attribute__((always_inline)) long _InterlockedAnd(volatile l
 	return y;
 }
 
-static __inline__ __attribute__((always_inline)) char _InterlockedOr8(volatile char * const value, const char mask)
+PPC_QUAL char _InterlockedOr8(volatile char * const value, const char mask)
 {
 	char x;
 	char y;
@@ -327,7 +347,7 @@ static __inline__ __attribute__((always_inline)) char _InterlockedOr8(volatile c
 	return y;
 }
 
-static __inline__ __attribute__((always_inline)) short _InterlockedOr16(volatile short * const value, const short mask)
+PPC_QUAL short _InterlockedOr16(volatile short * const value, const short mask)
 {
 	short x;
 	short y;
@@ -344,7 +364,7 @@ static __inline__ __attribute__((always_inline)) short _InterlockedOr16(volatile
 	return y;
 }
 
-static __inline__ __attribute__((always_inline)) long _InterlockedOr(volatile long * const value, const long mask)
+PPC_QUAL long _InterlockedOr(volatile long * const value, const long mask)
 {
 	long x;
 	long y;
@@ -361,7 +381,7 @@ static __inline__ __attribute__((always_inline)) long _InterlockedOr(volatile lo
 	return y;
 }
 
-static __inline__ __attribute__((always_inline)) char _InterlockedXor8(volatile char * const value, const char mask)
+PPC_QUAL char _InterlockedXor8(volatile char * const value, const char mask)
 {
 	char x;
 	char y;
@@ -378,7 +398,7 @@ static __inline__ __attribute__((always_inline)) char _InterlockedXor8(volatile
 	return y;
 }
 
-static __inline__ __attribute__((always_inline)) short _InterlockedXor16(volatile short * const value, const short mask)
+PPC_QUAL short _InterlockedXor16(volatile short * const value, const short mask)
 {
 	short x;
 	short y;
@@ -395,7 +415,7 @@ static __inline__ __attribute__((always_inline)) short _InterlockedXor16(volatil
 	return y;
 }
 
-static __inline__ __attribute__((always_inline)) long _InterlockedXor(volatile long * const value, const long mask)
+PPC_QUAL long _InterlockedXor(volatile long * const value, const long mask)
 {
 	long x;
 	long y;
@@ -412,7 +432,7 @@ static __inline__ __attribute__((always_inline)) long _InterlockedXor(volatile l
 	return y;
 }
 
-static __inline__ __attribute__((always_inline)) unsigned char _interlockedbittestandreset(volatile long * const a, const long b)
+PPC_QUAL unsigned char _interlockedbittestandreset(volatile long * const a, const long b)
 {
 	long x;
 	long y;
@@ -430,7 +450,7 @@ static __inline__ __attribute__((always_inline)) unsigned char _interlockedbitte
 	return (y & ~mask) != 0;
 }
 
-static __inline__ __attribute__((always_inline)) unsigned char _interlockedbittestandset(volatile long * const a, const long b)
+PPC_QUAL unsigned char _interlockedbittestandset(volatile long * const a, const long b)
 {
 	long x;
 	long y;
@@ -449,12 +469,12 @@ static __inline__ __attribute__((always_inline)) unsigned char _interlockedbitte
 }
 #endif
 
-static __inline__ __attribute__((always_inline)) long _InterlockedDecrement(volatile long * const lpAddend)
+PPC_QUAL long _InterlockedDecrement(volatile long * const lpAddend)
 {
 	return _InterlockedExchangeAdd(lpAddend, -1) - 1;
 }
 
-static __inline__ __attribute__((always_inline)) long _InterlockedIncrement(volatile long * const lpAddend)
+PPC_QUAL long _InterlockedIncrement(volatile long * const lpAddend)
 {
 	return _InterlockedExchangeAdd(lpAddend, 1) + 1;
 }
@@ -463,34 +483,34 @@ static __inline__ __attribute__((always_inline)) long _InterlockedIncrement(vola
 /* NOTE: we don't set a memory clobber in the __stosX functions because Visual C++ doesn't */
 /* Note that the PPC store multiple operations may raise an exception in LE 
  * mode */
-static __inline__ __attribute__((always_inline)) void __stosb(unsigned char * Dest, const unsigned char Data, unsigned long Count)
+PPC_QUAL void __stosb(unsigned char * Dest, const unsigned char Data, unsigned long Count)
 {
     memset(Dest, Data, Count);
 }
 
-static __inline__ __attribute__((always_inline)) void __stosw(unsigned short * Dest, const unsigned short Data, unsigned long Count)
+PPC_QUAL void __stosw(unsigned short * Dest, const unsigned short Data, unsigned long Count)
 {
     while(Count--) 
 	*Dest++ = Data;
 }
 
-static __inline__ __attribute__((always_inline)) void __stosd(unsigned long * Dest, const unsigned long Data, unsigned long Count)
+PPC_QUAL void __stosd(unsigned long * Dest, const unsigned long Data, unsigned long Count)
 {
     while(Count--)
 	*Dest++ = Data;
 }
 
-static __inline__ __attribute__((always_inline)) void __movsb(unsigned char * Destination, const unsigned char * Source, unsigned long Count)
+PPC_QUAL void __movsb(unsigned char * Destination, const unsigned char * Source, unsigned long Count)
 {
     memcpy(Destination, Source, Count);
 }
 
-static __inline__ __attribute__((always_inline)) void __movsw(unsigned short * Destination, const unsigned short * Source, unsigned long Count)
+PPC_QUAL void __movsw(unsigned short * Destination, const unsigned short * Source, unsigned long Count)
 {
     memcpy(Destination, Source, Count * sizeof(*Source));
 }
 
-static __inline__ __attribute__((always_inline)) void __movsd(unsigned long * Destination, const unsigned long * Source, unsigned long Count)
+PPC_QUAL void __movsd(unsigned long * Destination, const unsigned long * Source, unsigned long Count)
 {
     memcpy(Destination, Source, Count * sizeof(*Source));
 }
@@ -499,25 +519,25 @@ static __inline__ __attribute__((always_inline)) void __movsd(unsigned long * De
 /*** FS segment addressing ***/
 /* On PowerPC, r13 points to TLS data, including the TEB at 0(r13) from what I
  * can tell */
-static __inline__ __attribute__((always_inline)) void __writefsbyte(const unsigned long Offset, const unsigned char Data)
+PPC_QUAL void __writefsbyte(const unsigned long Offset, const unsigned char Data)
 {
     char *addr;
     __asm__("\tadd %0,13,%1\n\tstb %2,0(%0)" : "=r" (addr) : "r" (Offset), "r" (Data));
 }
 
-static __inline__ __attribute__((always_inline)) void __writefsword(const unsigned long Offset, const unsigned short Data)
+PPC_QUAL void __writefsword(const unsigned long Offset, const unsigned short Data)
 {
     char *addr;
     __asm__("\tadd %0,13,%1\n\tsth %2,0(%0)" : "=r" (addr) : "r" (Offset), "r" (Data));
 }
 
-static __inline__ __attribute__((always_inline)) void __writefsdword(const unsigned long Offset, const unsigned long Data)
+PPC_QUAL void __writefsdword(const unsigned long Offset, const unsigned long Data)
 {
     char *addr;
     __asm__("\tadd %0,13,%1\n\tstw %2,0(%0)" : "=r" (addr) : "r" (Offset), "r" (Data));
 }
 
-static __inline__ __attribute__((always_inline)) unsigned char __readfsbyte(const unsigned long Offset)
+PPC_QUAL unsigned char __readfsbyte(const unsigned long Offset)
 {
     unsigned short result;
     __asm__("\tadd 7,13,%1\n"
@@ -528,7 +548,7 @@ static __inline__ __attribute__((always_inline)) unsigned char __readfsbyte(cons
     return result;
 }
 
-static __inline__ __attribute__((always_inline)) unsigned short __readfsword(const unsigned long Offset)
+PPC_QUAL unsigned short __readfsword(const unsigned long Offset)
 {
     unsigned short result;
     __asm__("\tadd 7,13,%1\n"
@@ -539,7 +559,7 @@ static __inline__ __attribute__((always_inline)) unsigned short __readfsword(con
     return result;
 }
 
-static __inline__ __attribute__((always_inline)) unsigned long __readfsdword(const unsigned long Offset)
+PPC_QUAL unsigned long __readfsdword(const unsigned long Offset)
 {
     unsigned long result;
     __asm__("\tadd 7,13,%1\n"
@@ -550,41 +570,41 @@ static __inline__ __attribute__((always_inline)) unsigned long __readfsdword(con
     return result;
 }
 
-static __inline__ __attribute__((always_inline)) void __incfsbyte(const unsigned long Offset)
+PPC_QUAL void __incfsbyte(const unsigned long Offset)
 {
     __writefsbyte(Offset, __readfsbyte(Offset)+1);
 }
 
-static __inline__ __attribute__((always_inline)) void __incfsword(const unsigned long Offset)
+PPC_QUAL void __incfsword(const unsigned long Offset)
 {
     __writefsword(Offset, __readfsword(Offset)+1);
 }
 
-static __inline__ __attribute__((always_inline)) void __incfsdword(const unsigned long Offset)
+PPC_QUAL void __incfsdword(const unsigned long Offset)
 {
     __writefsdword(Offset, __readfsdword(Offset)+1);
 }
 
 /* NOTE: the bizarre implementation of __addfsxxx mimics the broken Visual C++ behavior */
 /* PPC Note: Not sure about the bizarre behavior.  We'll try to emulate it later */
-static __inline__ __attribute__((always_inline)) void __addfsbyte(const unsigned long Offset, const unsigned char Data)
+PPC_QUAL void __addfsbyte(const unsigned long Offset, const unsigned char Data)
 {
     __writefsbyte(Offset, __readfsbyte(Offset) + Data);
 }
 
-static __inline__ __attribute__((always_inline)) void __addfsword(const unsigned long Offset, const unsigned short Data)
+PPC_QUAL void __addfsword(const unsigned long Offset, const unsigned short Data)
 {
     __writefsword(Offset, __readfsword(Offset) + Data);
 }
 
-static __inline__ __attribute__((always_inline)) void __addfsdword(const unsigned long Offset, const unsigned int Data)
+PPC_QUAL void __addfsdword(const unsigned long Offset, const unsigned int Data)
 {
     __writefsdword(Offset, __readfsdword(Offset) + Data);
 }
 
 
 /*** Bit manipulation ***/
-static  __inline__ __attribute__((always_inline)) unsigned char _BitScanForward(unsigned long * const Index, const unsigned long Mask)
+PPC_QUAL unsigned char _BitScanForward(unsigned long * const Index, const unsigned long Mask)
 {
     if(Mask == 0) return 0;
     else {
@@ -601,7 +621,7 @@ static  __inline__ __attribute__((always_inline)) unsigned char _BitScanForward(
 }
 
 /* Thanks http://www.jjj.de/bitwizardry/files/bithigh.h */
-static  __inline__ __attribute__((always_inline)) unsigned char _BitScanReverse(unsigned long * const Index, const unsigned long Mask)
+PPC_QUAL unsigned char _BitScanReverse(unsigned long * const Index, const unsigned long Mask)
 {
     unsigned long check = 16, checkmask;
     if(Mask == 0) return 0;
@@ -621,82 +641,82 @@ static  __inline__ __attribute__((always_inline)) unsigned char _BitScanReverse(
 }
 
 /* NOTE: again, the bizarre implementation follows Visual C++ */
-static  __inline__ __attribute__((always_inline)) unsigned char _bittest(const long * const a, const long b)
+PPC_QUAL unsigned char _bittest(const long * const a, const long b)
 {
     return ((*a) & (1<<b)) != 0;
 }
 
-static __inline__ __attribute__((always_inline)) unsigned char _bittestandcomplement(long * const a, const long b)
+PPC_QUAL unsigned char _bittestandcomplement(long * const a, const long b)
 {
     unsigned char ret = ((*a) & (1<<b)) != 0;
     (*a) ^= (1<<b);
     return ret;
 }
 
-static __inline__ __attribute__((always_inline)) unsigned char _bittestandreset(long * const a, const long b)
+PPC_QUAL unsigned char _bittestandreset(long * const a, const long b)
 {
     unsigned char ret = ((*a) & (1<<b)) != 0;
     (*a) &= ~(1<<b);
     return ret;
 }
 
-static __inline__ __attribute__((always_inline)) unsigned char _bittestandset(long * const a, const long b)
+PPC_QUAL unsigned char _bittestandset(long * const a, const long b)
 {
     unsigned char ret = ((*a) & (1<<b)) != 0;
     (*a) |= (1<<b);
     return ret;
 }
 
-static __inline__ __attribute__((always_inline)) unsigned char _rotl8(const unsigned char value, const unsigned char shift)
+PPC_QUAL unsigned char _rotl8(const unsigned char value, const unsigned char shift)
 {
     return (value << shift) | (value >> (8-shift));
 }
 
-static __inline__ __attribute__((always_inline)) unsigned short _rotl16(const unsigned short value, const unsigned char shift)
+PPC_QUAL unsigned short _rotl16(const unsigned short value, const unsigned char shift)
 {
     return (value << shift) | (value >> (16-shift));    
 }
 
-static __inline__ __attribute__((always_inline)) unsigned char _rotr8(const unsigned char value, const unsigned char shift)
+PPC_QUAL unsigned char _rotr8(const unsigned char value, const unsigned char shift)
 {
     return (value >> shift) | (value << (8-shift));    
 }
 
-static __inline__ __attribute__((always_inline)) unsigned short _rotr16(const unsigned short value, const unsigned char shift)
+PPC_QUAL unsigned short _rotr16(const unsigned short value, const unsigned char shift)
 {
     return (value >> shift) | (value << (16-shift));    
 }
 
-static __inline__ __attribute__((always_inline)) unsigned long long __ll_lshift(const unsigned long long Mask, int Bit)
+PPC_QUAL unsigned long long __ll_lshift(const unsigned long long Mask, int Bit)
 {
     return Mask << Bit;
 }
 
-static __inline__ __attribute__((always_inline)) long long __ll_rshift(const long long Mask, const int Bit)
+PPC_QUAL long long __ll_rshift(const long long Mask, const int Bit)
 {
     return Mask >> Bit;
 }
 
-static __inline__ __attribute__((always_inline)) unsigned long long __ull_rshift(const unsigned long long Mask, int Bit)
+PPC_QUAL unsigned long long __ull_rshift(const unsigned long long Mask, int Bit)
 {
     return Mask >> Bit;
 }
 
 
 /*** 64-bit math ***/
-static __inline__ __attribute__((always_inline)) long long __emul(const int a, const int b)
+PPC_QUAL long long __emul(const int a, const int b)
 {
     return a * b;
 }
 
-static __inline__ __attribute__((always_inline)) unsigned long long __emulu(const unsigned int a, const unsigned int b)
+PPC_QUAL unsigned long long __emulu(const unsigned int a, const unsigned int b)
 {
     return a * b;
 }
 
 
 /*** Port I/O ***/
-static __inline__ __attribute__((always_inline)) unsigned char __inbyte(const unsigned short Port)
+PPC_QUAL unsigned char __inbyte(const unsigned short Port)
 {
     int ret;
     __asm__(
@@ -711,7 +731,7 @@ static __inline__ __attribute__((always_inline)) unsigned char __inbyte(const un
     return ret;
 }
 
-static __inline__ __attribute__((always_inline)) unsigned short __inword(const unsigned short Port)
+PPC_QUAL unsigned short __inword(const unsigned short Port)
 {
     int ret;
     __asm__(
@@ -726,7 +746,7 @@ static __inline__ __attribute__((always_inline)) unsigned short __inword(const u
     return ret;
 }
 
-static __inline__ __attribute__((always_inline)) unsigned long __indword(const unsigned short Port)
+PPC_QUAL unsigned long __indword(const unsigned short Port)
 {
     int ret;
     __asm__(
@@ -741,28 +761,28 @@ static __inline__ __attribute__((always_inline)) unsigned long __indword(const u
     return ret;
 }
 
-static __inline__ __attribute__((always_inline)) void __inbytestring(unsigned short Port, unsigned char * Buffer, unsigned long Count)
+PPC_QUAL void __inbytestring(unsigned short Port, unsigned char * Buffer, unsigned long Count)
 {
     while(Count--) {
 	*Buffer++ = __inbyte(Port);
     }
 }
 
-static __inline__ __attribute__((always_inline)) void __inwordstring(unsigned short Port, unsigned short * Buffer, unsigned long Count)
+PPC_QUAL void __inwordstring(unsigned short Port, unsigned short * Buffer, unsigned long Count)
 {
     while(Count--) {
 	*Buffer++ = __inword(Port);
     }
 }
 
-static __inline__ __attribute__((always_inline)) void __indwordstring(unsigned short Port, unsigned long * Buffer, unsigned long Count)
+PPC_QUAL void __indwordstring(unsigned short Port, unsigned long * Buffer, unsigned long Count)
 {
     while(Count--) {
 	*Buffer++ = __indword(Port);
     }
 }
 
-static __inline__ __attribute__((always_inline)) void __outbyte(unsigned short const Port, const unsigned char Data)
+PPC_QUAL void __outbyte(unsigned short const Port, const unsigned char Data)
 {
     __asm__(
 	"mfmsr 5\n\t"
@@ -778,7 +798,7 @@ static __inline__ __attribute__((always_inline)) void __outbyte(unsigned short c
 	);
 }
 
-static __inline__ __attribute__((always_inline)) void __outword(unsigned short const Port, const unsigned short Data)
+PPC_QUAL void __outword(unsigned short const Port, const unsigned short Data)
 {
     __asm__(
 	"mfmsr 5\n\t"
@@ -794,7 +814,7 @@ static __inline__ __attribute__((always_inline)) void __outword(unsigned short c
 	);
 }
 
-static __inline__ __attribute__((always_inline)) void __outdword(unsigned short const Port, const unsigned long Data)
+PPC_QUAL void __outdword(unsigned short const Port, const unsigned long Data)
 {
     __asm__(
 	"mfmsr 5\n\t"
@@ -810,7 +830,7 @@ static __inline__ __attribute__((always_inline)) void __outdword(unsigned short
 	);
 }
 
-static __inline__ __attribute__((always_inline)) void __outbytestring(unsigned short const Port, const unsigned char * const Buffer, const unsigned long Count)
+PPC_QUAL void __outbytestring(unsigned short const Port, const unsigned char * const Buffer, const unsigned long Count)
 {
     unsigned long count = Count;
     const unsigned char *buffer = Buffer;
@@ -819,7 +839,7 @@ static __inline__ __attribute__((always_inline)) void __outbytestring(unsigned s
     }
 }
 
-static __inline__ __attribute__((always_inline)) void __outwordstring(unsigned short const Port, const unsigned short * const Buffer, const unsigned long Count)
+PPC_QUAL void __outwordstring(unsigned short const Port, const unsigned short * const Buffer, const unsigned long Count)
 {
     unsigned long count = Count;
     const unsigned short *buffer = Buffer;
@@ -828,7 +848,7 @@ static __inline__ __attribute__((always_inline)) void __outwordstring(unsigned s
     }
 }
 
-static __inline__ __attribute__((always_inline)) void __outdwordstring(unsigned short const Port, const unsigned long * const Buffer, const unsigned long Count)
+PPC_QUAL void __outdwordstring(unsigned short const Port, const unsigned long * const Buffer, const unsigned long Count)
 {
     unsigned long count = Count;
     const unsigned long *buffer = Buffer;
@@ -839,13 +859,13 @@ static __inline__ __attribute__((always_inline)) void __outdwordstring(unsigned
 
 
 /*** System information ***/
-static __inline__ __attribute__((always_inline)) void __cpuid(int CPUInfo[], const int InfoType)
+PPC_QUAL void __cpuid(int CPUInfo[], const int InfoType)
 {
     unsigned long lo32;
     __asm__("mfpvr" : "=b" (lo32));
 }
 
-static __inline__ __attribute__((always_inline)) unsigned long long __rdtsc(void)
+PPC_QUAL unsigned long long __rdtsc(void)
 {
     unsigned long lo32;
     __asm__("mfdec %0" : "=b" (lo32));
@@ -855,19 +875,19 @@ static __inline__ __attribute__((always_inline)) unsigned long long __rdtsc(void
 
 /*** Interrupts ***/
 /* Finally decided to do this by enabling single step trap */
-static __inline__ __attribute__((always_inline)) void __debugbreak(void)
+PPC_QUAL void __debugbreak(void)
 {
     
 }
 
-static __inline__ __attribute__((always_inline)) void __int2c(void)
+PPC_QUAL void __int2c(void)
 {
     /* Not sure yet */
 }
 
 #ifndef _ENABLE_DISABLE_DEFINED
 #define _ENABLE_DISABLE_DEFINED
-static __inline__ __attribute__((always_inline)) void _disable(void)
+PPC_QUAL void _disable(void)
 {
     __asm__ __volatile__("mfmsr 0\n\t" \
 			 "li    8,0x7fff\n\t" \
@@ -875,7 +895,7 @@ static __inline__ __attribute__((always_inline)) void _disable(void)
 			 "mtmsr 0\n\t");
 }
 
-static __inline__ __attribute__((always_inline)) void _enable(void)
+PPC_QUAL void _enable(void)
 {
  __asm__ __volatile__("mfmsr 0\n\t" \
                       "lis    8,0x8000@ha\n\t" \
@@ -884,14 +904,14 @@ static __inline__ __attribute__((always_inline)) void _enable(void)
 }
 
 /*** Protected memory management ***/
-static __inline__ __attribute__((always_inline)) unsigned long __readsdr1(void)
+PPC_QUAL unsigned long __readsdr1(void)
 {
     unsigned long value;
     __asm__("mfsdr1 %0" : "=b" (value));
     return value;
 }
 
-static __inline__ __attribute__((always_inline)) void __writesdr1(const unsigned long long Data)
+PPC_QUAL void __writesdr1(const unsigned long long Data)
 {
     __asm__("mtsdr1 %0" : : "b" (Data));
 }
@@ -899,14 +919,14 @@ static __inline__ __attribute__((always_inline)) void __writesdr1(const unsigned
 /*** System operations ***/
 /* This likely has a different meaning from the X86 equivalent.  We'll keep
  * the name cause it fits */
-static __inline__ __attribute__((always_inline)) unsigned long long __readmsr()
+PPC_QUAL unsigned long long __readmsr()
 {
     unsigned long temp;
     __asm__("mfmsr %0" : "=b" (temp));
     return temp;
 }
 
-static __inline__ __attribute__((always_inline)) void __writemsr(const unsigned long Value)
+PPC_QUAL void __writemsr(const unsigned long Value)
 {
     __asm__("mtmsr %0" : : "b" (Value));
 }
@@ -917,7 +937,7 @@ static __inline__ __attribute__((always_inline)) void __writemsr(const unsigned
  * We've reloaded anything in the data or instruction cache that might have
  * changed in real ram.
  */
-static __inline__ __attribute__((always_inline)) void __wbinvd(void)
+PPC_QUAL void __wbinvd(void)
 {
     __asm__("eieio\n\t"
 	    "dcs\n\t"
@@ -926,7 +946,7 @@ static __inline__ __attribute__((always_inline)) void __wbinvd(void)
 }
 #endif
 
-static __inline__ __attribute__((always_inline)) long _InterlockedAddLargeStatistic(volatile long long * const Addend, const long Value)
+PPC_QUAL long _InterlockedAddLargeStatistic(volatile long long * const Addend, const long Value)
 {
 #if 0
 	__asm__
diff --git a/reactos/include/psdk/winnt.h b/reactos/include/psdk/winnt.h
index f7cfc651f57..e244460f68b 100644
--- a/reactos/include/psdk/winnt.h
+++ b/reactos/include/psdk/winnt.h
@@ -2021,7 +2021,7 @@ typedef struct _ACL_SIZE_INFORMATION {
 } ACL_SIZE_INFORMATION;
 
 /* FIXME: add more machines */
-#if defined(_X86_) || defined(unix)
+#if defined(_X86_) || defined(unix) && !defined(__PowerPC__)
 #define SIZE_OF_80387_REGISTERS	80
 #define CONTEXT_i386	0x10000
 #define CONTEXT_i486	0x10000
@@ -2077,7 +2077,8 @@ typedef struct _CONTEXT {
 #define CONTEXT_INTEGER	4L
 #define CONTEXT_DEBUG_REGISTERS	8L
 #define CONTEXT_FULL (CONTEXT_CONTROL|CONTEXT_FLOATING_POINT|CONTEXT_INTEGER)
-typedef struct _CONTEXT {
+typedef struct _FLOATING_SAVE_AREA
+{
 	double Fpr0;
 	double Fpr1;
 	double Fpr2;
@@ -2111,6 +2112,10 @@ typedef struct _CONTEXT {
 	double Fpr30;
 	double Fpr31;
 	double Fpscr;
+} FLOATING_SAVE_AREA;
+
+typedef struct _CONTEXT {
+        FLOATING_SAVE_AREA FloatSave;
 	DWORD Gpr0;
 	DWORD Gpr1;
 	DWORD Gpr2;
@@ -4101,6 +4106,11 @@ static __inline__ struct _TEB * NtCurrentTeb(void)
     return __readfsdword_winnt(0x18);
 }
 #endif
+#elif defined(_M_PPC)
+static __inline__ struct _TEB * NtCurrentTeb(void)
+{
+    return __readfsdword_winnt(0x18);
+}
 #endif
 
 #elif defined(__WATCOMC__)
diff --git a/reactos/lib/lib.rbuild b/reactos/lib/lib.rbuild
index 866f5380361..ae23fcba0b6 100644
--- a/reactos/lib/lib.rbuild
+++ b/reactos/lib/lib.rbuild
@@ -25,6 +25,9 @@
 	<directory name="inflib">
 		<xi:include href="inflib/inflib.rbuild" />
 	</directory>
+	<directory name="ppcmmu">
+		<xi:include href="ppcmmu/ppcmmu.rbuild" />
+	</directory>
 	<directory name="pseh">
 		<xi:include href="pseh/pseh.rbuild" />
 	</directory>
diff --git a/reactos/lib/pseh/powerpc/framebased.S b/reactos/lib/pseh/powerpc/framebased.S
new file mode 100644
index 00000000000..0f0c077ef29
--- /dev/null
+++ b/reactos/lib/pseh/powerpc/framebased.S
@@ -0,0 +1,82 @@
+// Copyright (c) 2004/2005 KJK::Hyperion
+
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to dos so, subject to the following conditions:
+
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
+.text
+
+__readfsdword:
+        add 7,13,3
+        lwz 3,0(7)
+        blr
+
+__writefsdword:
+        add 7,13,3
+        stw 3,0(7)
+        blr
+        
+.globl _SEHCleanHandlerEnvironment
+_SEHCleanHandlerEnvironment:
+        blr
+
+.globl _SEHCurrentRegistration
+_SEHCurrentRegistration:
+        xor 3,0,0
+        bl __readfsdword
+        blr
+
+.globl _SEHRegisterFrame
+_SEHRegisterFrame:
+        xor 3,0,0
+        bl __readfsdword        # Get [fs:0]
+        lwz 4,0(1)              # Get next stack frame into r4
+        stw 3,0(1)              # put [fs:0] into old stack pos
+        xor 3,0,0
+        bl __writefsdword       # put old stack frame into [fs:0] completing
+        blr                     # the chain and return
+
+.globl _SEHUnregisterFrame
+_SEHUnregisterFrame:
+        xor 3,0,0
+        bl __readfsdword        # Get old next frame ptr
+        stw 3,0(1)              # Reset old stack frame
+        blr
+
+.globl _SEHGlobalUnwind
+_SEHGlobalUnwind:
+
+.extern _SEHRtlUnwind
+
+// RtlUnwind clobbers all the "don't clobber" registers, so we save them
+        lwz 3,4(1)
+        stwu 1,-132(1)
+        stmw 2,-128(1)
+        
+        xor 6,6,6
+        xor 5,5,5
+        lis 4,.RestoreRegisters@ha
+        addi 4,4,.RestoreRegisters@l # Where to jump back to
+        # We already have r3
+        bl _SEHRtlUnwind
+
+.RestoreRegisters:
+        lmw 2,-128(1)
+        addi 1,1,132
+        blr
+
+// EOF
diff --git a/reactos/lib/pseh/pseh.rbuild b/reactos/lib/pseh/pseh.rbuild
index 63f0c2addc6..41b60efe5f6 100644
--- a/reactos/lib/pseh/pseh.rbuild
+++ b/reactos/lib/pseh/pseh.rbuild
@@ -7,5 +7,10 @@
 			<file>framebased.S</file>
 		</directory>
 	</if>
+	<if property="ARCH" value="powerpc">
+		<directory name="powerpc">
+			<file>framebased.S</file>
+		</directory>
+	</if>
 	<file>framebased.c</file>
 </module>
diff --git a/reactos/lib/rtl/powerpc/rtlmem.s b/reactos/lib/rtl/powerpc/rtlmem.s
new file mode 100644
index 00000000000..12c98c60aa3
--- /dev/null
+++ b/reactos/lib/rtl/powerpc/rtlmem.s
@@ -0,0 +1,105 @@
+/*
+ *
+ */
+
+.globl RtlCompareMemory
+.globl RtlCompareMemoryUlong
+.globl RtlFillMemory
+.globl RtlFillMemoryUlong
+.globl RtlFillMemoryUlonglong
+.globl RtlMoveMemory
+.globl RtlZeroMemory
+.globl RtlPrefetchMemoryNonTemporal
+        
+RtlCompareMemory:
+1:
+        mr 0,5
+        
+        cmpwi 0,5,4
+        blt 2f
+
+        lwz 6,0(3)
+        lwz 7,0(3)
+        addi 6,6,-7
+        cmpwi 0,6,0
+        bne 2f
+
+        addi 3,3,4
+        addi 4,4,4
+        subi 5,5,4
+        b 1b
+        
+2:      
+        cmpwi 0,5,0
+        beq 3f
+        
+        lbz 6,0(3)
+        lbz 7,0(4)
+        addi 6,6,-7
+        cmpwi 0,6,0
+        bne 3f
+        
+        addi 3,3,1
+        addi 4,4,1
+        subi 5,5,1
+        b 2b
+
+3:
+        mr 4,0
+        sub 3,4,5
+        blr
+        
+RtlCompareMemoryUlong:
+        or 6,3,4
+        or 6,6,5
+        andi. 6,6,3
+        bne RtlCompareMemory
+        xor 3,3,3
+        blr
+        
+RtlFillMemory:
+        rlwinm 6,5,8,0xff00
+        rlwinm 7,5,0,0xff
+        or 7,6,7
+        rlwinm 5,7,16,0xffff0000
+        or 5,7,5
+        
+1:      
+        cmpwi 0,4,4
+        blt 2f
+
+        stw 5,0(3)
+        
+        addi 3,3,4
+        subi 4,4,4
+        b 1b
+
+2:
+        cmpwi 0,4,0
+        beq 3f
+
+        stb 5,0(3)
+        
+        addi 3,3,1
+        subi 4,4,1
+        b 2b
+
+3:
+        blr
+        
+RtlFillMemoryUlong:
+        b RtlFillMemory
+        
+RtlFillMemoryUlonglong:
+        b RtlFillMemoryUlong
+
+RtlMoveMemory:  
+        b memmove
+        
+RtlZeroMemory:
+        mr 5,4
+        xor 4,4,4
+        b memset
+
+RtlPrefetchMemoryNonTemporal:
+        blr
diff --git a/reactos/lib/rtl/powerpc/rtlswap.s b/reactos/lib/rtl/powerpc/rtlswap.s
new file mode 100644
index 00000000000..6455fa5b9bd
--- /dev/null
+++ b/reactos/lib/rtl/powerpc/rtlswap.s
@@ -0,0 +1,41 @@
+/*
+ * COPYRIGHT:         See COPYING in the top level directory
+ * PROJECT:           ReactOS Run-Time Library
+ * PURPOSE:           Byte swap functions
+ * FILE:              lib/rtl/i386/rtlswap.S
+ * PROGRAMER:         Alex Ionescu (alex.ionescu@reactos.org)
+ */
+
+.globl RtlUshortByteSwap
+.globl RtlUlongByteSwap
+.globl RtlUlonglongByteSwap
+
+/* FUNCTIONS ***************************************************************/
+
+RtlUshortByteSwap:
+    /* Swap high and low bits */
+    rlwinm 4,3,24,0xff
+    rlwinm 5,3,8,0xff00
+    or 3,4,5
+    blr
+
+RtlUlongByteSwap:
+    rlwinm 4,3,8,0xff
+    rlwinm 5,3,24,0xff000000
+    or 4,4,5
+    rlwinm 5,3,8,0xff0000
+    rlwinm 3,3,24,0xff00
+    or 3,4,5
+    or 3,3,6
+    blr
+
+RtlUlonglongByteSwap:
+    stwu 1,16(1)
+    stw 4,4(1)
+    bl RtlUlongByteSwap
+    stw 3,4(1)
+    lwz 3,4(1)
+    bl RtlUlongByteSwap
+    lwz 4,4(1)
+    subi 1,1,16
+    blr
diff --git a/reactos/lib/rtl/rtl.rbuild b/reactos/lib/rtl/rtl.rbuild
index 83a9ff3b670..4d8f452e289 100644
--- a/reactos/lib/rtl/rtl.rbuild
+++ b/reactos/lib/rtl/rtl.rbuild
@@ -25,6 +25,8 @@
 		<file>debug.c</file>
 		<file>except.c</file>
 		<file>interlocked.c</file>
+                <file>rtlmem.s</file>
+                <file>rtlswap.s</file>
 		<file>thread.c</file>
 	</directory>
 	</if>
diff --git a/reactos/lib/sdk/libcntpr/except/powerpc/chkstk_asm.s b/reactos/lib/sdk/libcntpr/except/powerpc/chkstk_asm.s
new file mode 100644
index 00000000000..653fec4dd07
--- /dev/null
+++ b/reactos/lib/sdk/libcntpr/except/powerpc/chkstk_asm.s
@@ -0,0 +1,23 @@
+/* $Id: chkstk_asm.s 26099 2007-03-14 20:30:32Z ion $
+ *
+ * COPYRIGHT:         See COPYING in the top level directory
+ * PROJECT:           ReactOS kernel
+ * PURPOSE:           Stack checker
+ * FILE:              lib/ntdll/rtl/i386/chkstk.s
+ * PROGRAMER:         arty
+ */
+
+.globl _chkstk
+.globl _alloca_probe
+
+/*
+ _chkstk() is called by all stack allocations of more than 4 KB. It grows the
+ stack in areas of 4 KB each, trying to access each area. This ensures that the
+ guard page for the stack is hit, and the stack growing triggered
+ */
+_chkstk:
+_alloca_probe:
+        /* return */
+        blr
+
+/* EOF */
diff --git a/reactos/lib/sdk/libcntpr/except/powerpc/seh.s b/reactos/lib/sdk/libcntpr/except/powerpc/seh.s
new file mode 100644
index 00000000000..4965d634b9b
--- /dev/null
+++ b/reactos/lib/sdk/libcntpr/except/powerpc/seh.s
@@ -0,0 +1,75 @@
+/*
+ * COPYRIGHT:       See COPYING in the top level directory
+ * PROJECT:         ReactOS CRT
+ * FILE:            lib/crt/misc/i386/seh.S
+ * PURPOSE:         SEH Support for the CRT
+ * PROGRAMMERS:     arty
+ */
+
+/* INCLUDES ******************************************************************/
+
+#include <ndk/asm.h>
+
+#define DISPOSITION_DISMISS         0
+#define DISPOSITION_CONTINUE_SEARCH 1
+#define DISPOSITION_COLLIDED_UNWIND 3
+
+/* GLOBALS *******************************************************************/
+
+.globl _global_unwind2
+.globl _local_unwind2
+.globl _abnormal_termination
+.globl _except_handler2
+.globl _except_handler3
+
+/* FUNCTIONS *****************************************************************/
+
+unwind_handler:
+        blr
+
+_global_unwind2:
+        blr
+
+_local_unwind2:
+        blr
+
+_except_handler2:
+        blr
+
+_except_handler3:
+        blr
+
+//
+//
+// REMOVE ME REMOVE ME REMOVE ME REMOVE ME REMOVE ME REMOVE ME REMOVE ME
+// sorry
+//
+//
+.globl RtlpGetStackLimits
+RtlpGetStackLimits:
+        stwu 1,16(1)
+        mflr 0
+        
+        stw 0,4(1)
+        stw 3,8(1)
+        stw 4,12(1)
+        
+        /* Get the current thread */
+        lwz 3,KPCR_CURRENT_THREAD(13)
+
+        /* Get the stack limits */
+        lwz 4,KTHREAD_STACK_LIMIT(3)
+        lwz 5,KTHREAD_INITIAL_STACK(3)
+        subi 5,5,SIZEOF_FX_SAVE_AREA
+
+        /* Return them */
+        lwz 3,8(1)
+        stw 4,0(3)
+
+        lwz 3,12(1)
+        stw 5,0(3)
+
+        addi 1,1,16
+        
+        /* return */
+        blr
diff --git a/reactos/lib/sdk/libcntpr/libcntpr.rbuild b/reactos/lib/sdk/libcntpr/libcntpr.rbuild
index 65f677221bf..f2ebc93befe 100644
--- a/reactos/lib/sdk/libcntpr/libcntpr.rbuild
+++ b/reactos/lib/sdk/libcntpr/libcntpr.rbuild
@@ -19,8 +19,13 @@
 				<file>seh.s</file>
 			</directory>
 		</if>
+		<if property="ARCH" value="powerpc">
+			<directory name="powerpc">
+				<file>chkstk_asm.s</file>
+				<file>seh.s</file>
+			</directory>
+		</if>
 	</directory>
-
 	<directory name="math">
 		<if property="ARCH" value="i386">
 			<directory name="i386">
diff --git a/reactos/ntoskrnl/config/powerpc/cmhardwr.c b/reactos/ntoskrnl/config/powerpc/cmhardwr.c
new file mode 100644
index 00000000000..78d15a02d50
--- /dev/null
+++ b/reactos/ntoskrnl/config/powerpc/cmhardwr.c
@@ -0,0 +1,834 @@
+/*
+ * PROJECT:         ReactOS Kernel
+ * LICENSE:         GPL - See COPYING in the top level directory
+ * FILE:            ntoskrnl/config/i386/cmhardwr.c
+ * PURPOSE:         Configuration Manager - Hardware-Specific Code
+ * PROGRAMMERS:     Alex Ionescu (alex.ionescu@reactos.org)
+ */
+
+/* INCLUDES ******************************************************************/
+
+#include "ntoskrnl.h"
+#include "../cm.h"
+#define NDEBUG
+#include "debug.h"
+
+/* GLOBALS *******************************************************************/
+
+PCHAR CmpID1 = "PowerPC %u";
+PCHAR CmpID2 = "No Data";
+PCHAR CmpBiosStrings[] =
+{
+    "Ver",
+    "Rev",
+    "Rel",
+    "v0", "v1", "v2", "v3", "v4", "v5", "v6", "v7", "v8", "v9",
+    "v 0", "v 1", "v 2", "v 3", "v 4", "v 5", "v 6", "v 7", "v 8", "v 9",
+    NULL
+};
+
+PCHAR CmpBiosBegin, CmpBiosSearchStart, CmpBiosSearchEnd;
+
+/* FUNCTIONS *****************************************************************/
+
+BOOLEAN
+NTAPI
+CmpGetBiosDate(IN PCHAR BiosStart,
+               IN ULONG BiosLength,
+               IN PCHAR BiosDate,
+               IN BOOLEAN FromBios)
+{
+    CHAR LastDate[11] = {0}, CurrentDate[11];
+    PCHAR p, pp;
+
+    /* Skip the signature and the magic, and loop the BIOS ROM */
+    p = BiosStart + 2;
+    pp = BiosStart + BiosLength - 5;
+    while (p < pp)
+    {
+        /* Check for xx/yy/zz which we assume to be a date */
+        if ((p[0] == '/') &&
+            (p[3] == '/') &&
+            (isdigit(p[-1])) &&
+            (isdigit(p[1])) &&
+            (isdigit(p[2])) &&
+            (isdigit(p[4])) &&
+            (isdigit(p[5])))
+        {
+            /* Copy the string proper */
+            RtlMoveMemory(&CurrentDate[5], p - 2, 5);
+
+            /* Add a 0 if the month only has one digit */
+            if (!isdigit(CurrentDate[5])) CurrentDate[5] = '0';
+
+            /* Now copy the year */
+            CurrentDate[2] = p[4];
+            CurrentDate[3] = p[5];
+            CurrentDate[4] = CurrentDate[7] = CurrentDate[10] = ANSI_NULL;
+
+            /* If the date comes from the BIOS, check if it's a 4-digit year */
+            if ((FromBios) &&
+                (isdigit(p[6])) &&
+                (isdigit(p[7])) &&
+                ((RtlEqualMemory(&p[4], "19", 2)) ||
+                 (RtlEqualMemory(&p[4], "20", 2))))
+            {
+                /* Copy the year proper */
+                CurrentDate[0] = p[4];
+                CurrentDate[1] = p[5];
+                CurrentDate[2] = p[6];
+                CurrentDate[3] = p[7];
+            }
+            else
+            {
+                /* Otherwise, we'll just assume anything under 80 is 2000 */
+                if (strtoul(&CurrentDate[2], NULL, 10) < 80)
+                {
+                    /* Hopefully your BIOS wasn't made in 1979 */
+                    CurrentDate[0] = '2';
+                    CurrentDate[1] = '0';
+                }
+                else
+                {
+                    /* Anything over 80, was probably made in the 1900s... */
+                    CurrentDate[0] = '1';
+                    CurrentDate[1] = '9';
+                }
+            }
+
+            /* Add slashes were we previously had NULLs */
+            CurrentDate[4] = CurrentDate[7] = '/';
+
+            /* Check which date is newer */
+            if (memcmp(LastDate, CurrentDate, 10) < 0)
+            {
+                /* Found a newer date, select it */
+                RtlMoveMemory(LastDate, CurrentDate, 10);
+            }
+
+            p += 2;
+        }
+        p++;
+    }
+
+    /* Make sure we found a date */
+    if (LastDate[0])
+    {
+        /* Copy the year at the pp, and keep only the last two digits */
+        RtlMoveMemory(BiosDate, &LastDate[5], 5);
+        BiosDate[5] = '/';
+        BiosDate[6] = LastDate[2];
+        BiosDate[7] = LastDate[3];
+        BiosDate[8] = ANSI_NULL;
+        return TRUE;
+    }
+
+    /* No date found, return empty string */
+    BiosDate[0] = ANSI_NULL;
+    return FALSE;
+}
+
+BOOLEAN
+NTAPI
+CmpGetBiosVersion(IN PCHAR BiosStart,
+                  IN ULONG BiosLength,
+                  IN PCHAR BiosVersion)
+{
+    CHAR Buffer[128];
+    PCHAR p, pp;
+    USHORT i;
+
+    /* Check if we were given intitial data for the search */
+    if (BiosStart)
+    {
+        /* Save it for later use */
+        CmpBiosBegin = BiosStart;
+        CmpBiosSearchStart = BiosStart + 1;
+        CmpBiosSearchEnd = BiosStart + BiosLength - 2;
+    }
+
+    /* Now loop the BIOS area */
+    for (;;)
+    {
+        /* Start an initial search looking for numbers and periods */
+        pp = NULL;
+        while (CmpBiosSearchStart <= CmpBiosSearchEnd)
+        {
+            /* Check if we have an "x.y" version string */
+            if ((*CmpBiosSearchStart == '.') &&
+                (*(CmpBiosSearchStart + 1) >= '0') &&
+                (*(CmpBiosSearchStart + 1) <= '9') &&
+                (*(CmpBiosSearchStart - 1) >= '0') &&
+                (*(CmpBiosSearchStart - 1) <= '9'))
+            {
+                /* Start looking in this area for the actual BIOS Version */
+                pp = CmpBiosSearchStart;
+                break;
+            }
+            else
+            {
+                /* Keep searching */
+                CmpBiosSearchStart++;
+            }
+        }
+
+        /* Break out if we're went past the BIOS area */
+        if (CmpBiosSearchStart > CmpBiosSearchEnd) return FALSE;
+
+        /* Move to the next 2 bytes */
+        CmpBiosSearchStart += 2;
+
+        /* Null-terminate our scratch buffer and start the string here */
+        Buffer[127] = ANSI_NULL;
+        p = &Buffer[127];
+
+        /* Go back one character since we're doing this backwards */
+        pp--;
+
+        /* Loop the identifier we found as long as it's valid */
+        i = 0;
+        while ((i++ < 127) &&
+               (pp >= CmpBiosBegin) &&
+               (*pp >= ' ') &&
+               (*pp != '$'))
+        {
+            /* Copy the character */
+            *--p = *pp--;
+        }
+
+        /* Go past the last character since we went backwards */
+        pp++;
+
+        /* Loop the strings we recognize */
+        for (i = 0; CmpBiosStrings[i]; i++)
+        {
+            /* Check if a match was found */
+            if (strstr(p, CmpBiosStrings[i])) goto Match;
+        }
+    }
+
+Match:
+    /* Skip until we find a space */
+    for (; *pp == ' '; pp++);
+
+    /* Loop the final string */
+    i = 0;
+    do
+    {
+        /* Copy the character into the final string */
+        BiosVersion[i] = *pp++;
+    } while ((++i < 127) &&
+             (pp <= (CmpBiosSearchEnd + 1)) &&
+             (*pp >= ' ') &&
+             (*pp != '$'));
+
+    /* Null-terminate the version string */
+    BiosVersion[i] = ANSI_NULL;
+    return TRUE;
+}
+
+NTSTATUS
+NTAPI
+CmpInitializeMachineDependentConfiguration(IN PLOADER_PARAMETER_BLOCK LoaderBlock)
+{
+    UNICODE_STRING KeyName, ValueName, Data, SectionName;
+    OBJECT_ATTRIBUTES ObjectAttributes;
+    ULONG HavePae, CacheSize, ViewSize, Length, TotalLength = 0, i, Disposition;
+    NTSTATUS Status;
+    HANDLE KeyHandle, BiosHandle, SystemHandle, FpuHandle, SectionHandle;
+    CONFIGURATION_COMPONENT_DATA ConfigData;
+    CHAR Buffer[128];
+    ULONG ExtendedId = 0; //, Dummy;
+    PKPRCB Prcb;
+    USHORT IndexTable[MaximumType + 1] = {0};
+    ANSI_STRING TempString;
+    PCHAR PartialString = NULL, BiosVersion;
+    CHAR CpuString[48];
+    PVOID BaseAddress = NULL;
+    LARGE_INTEGER ViewBase = {{0}};
+    ULONG_PTR VideoRomBase;
+    PCHAR CurrentVersion;
+    extern UNICODE_STRING KeRosProcessorName, KeRosBiosDate, KeRosBiosVersion;
+    extern UNICODE_STRING KeRosVideoBiosDate, KeRosVideoBiosVersion;
+    
+    /* Open the SMSS Memory Management key */
+    RtlInitUnicodeString(&KeyName,
+                         L"\\Registry\\Machine\\SYSTEM\\CurrentControlSet\\"
+                         L"Control\\Session Manager\\Memory Management");
+    InitializeObjectAttributes(&ObjectAttributes,
+                               &KeyName,
+                               OBJ_CASE_INSENSITIVE,
+                               NULL,
+                               NULL);
+    Status = NtOpenKey(&KeyHandle, KEY_READ | KEY_WRITE, &ObjectAttributes);
+    if (NT_SUCCESS(Status))
+    {
+        /* Detect if PAE is enabled */
+        HavePae = SharedUserData->ProcessorFeatures[PF_PAE_ENABLED];
+
+        /* Set the value */
+        RtlInitUnicodeString(&ValueName, L"PhysicalAddressExtension");
+        NtSetValueKey(KeyHandle,
+                      &ValueName,
+                      0,
+                      REG_DWORD,
+                      &HavePae,
+                      sizeof(HavePae));
+
+        /* Close the key */
+        NtClose(KeyHandle);
+    }
+
+    /* Open the hardware description key */
+    RtlInitUnicodeString(&KeyName,
+                         L"\\Registry\\Machine\\Hardware\\Description\\System");
+    InitializeObjectAttributes(&ObjectAttributes,
+                               &KeyName,
+                               OBJ_CASE_INSENSITIVE,
+                               NULL,
+                               NULL);
+    Status = NtOpenKey(&SystemHandle, KEY_READ | KEY_WRITE, &ObjectAttributes);
+    if (!NT_SUCCESS(Status)) return Status;
+
+    /* Create the BIOS Information key */
+    RtlInitUnicodeString(&KeyName,
+                         L"\\Registry\\Machine\\SYSTEM\\CurrentControlSet\\"
+                         L"Control\\BIOSINFO");
+    InitializeObjectAttributes(&ObjectAttributes,
+                               &KeyName,
+                               OBJ_CASE_INSENSITIVE,
+                               NULL,
+                               NULL);
+    Status = NtCreateKey(&BiosHandle,
+                         KEY_ALL_ACCESS,
+                         &ObjectAttributes,
+                         0,
+                         NULL,
+                         REG_OPTION_NON_VOLATILE,
+                         &Disposition);
+    if (ExpInTextModeSetup)
+    {
+        if (!NT_SUCCESS(Status))
+            BiosHandle = NULL;
+    }
+    else if (!NT_SUCCESS(Status))
+        return Status;
+
+    /* Create the CPU Key, and check if it already existed */
+    RtlInitUnicodeString(&KeyName, L"CentralProcessor");
+    InitializeObjectAttributes(&ObjectAttributes,
+                               &KeyName,
+                               OBJ_CASE_INSENSITIVE,
+                               SystemHandle,
+                               NULL);
+    Status = NtCreateKey(&KeyHandle,
+                         KEY_READ | KEY_WRITE,
+                         &ObjectAttributes,
+                         0,
+                         NULL,
+                         0,
+                         &Disposition);
+    NtClose(KeyHandle);
+
+    /* The key shouldn't already exist */
+    if (Disposition == REG_CREATED_NEW_KEY)
+    {
+        /* Allocate the configuration data for cmconfig.c */
+        CmpConfigurationData = ExAllocatePoolWithTag(PagedPool,
+                                                     CmpConfigurationAreaSize,
+                                                     TAG_CM);
+        if (!CmpConfigurationData) return STATUS_INSUFFICIENT_RESOURCES;
+
+        /* Loop all CPUs */
+        for (i = 0; i < KeNumberProcessors; i++)
+        {
+            /* Get the PRCB */
+            Prcb = KiProcessorBlock[i];
+
+            /* Setup the Configuration Entry for the Processor */
+            RtlZeroMemory(&ConfigData, sizeof (ConfigData));
+            ConfigData.ComponentEntry.Class = ProcessorClass;
+            ConfigData.ComponentEntry.Type = CentralProcessor;
+            ConfigData.ComponentEntry.Key = i;
+            ConfigData.ComponentEntry.AffinityMask = AFFINITY_MASK(i);
+            ConfigData.ComponentEntry.Identifier = Buffer;
+
+            /* Check if the CPU doesn't support CPUID */
+            if (!Prcb->CpuID)
+            {
+                /* Build ID1-style string for older CPUs */
+                sprintf(Buffer,
+                        CmpID1,
+                        Prcb->CpuType,
+                        (Prcb->CpuStep >> 8) + 'A',
+                        Prcb->CpuStep & 0xff);
+            }
+            else
+            {
+                /* Build ID2-style string for newer CPUs */
+                sprintf(Buffer,
+                        CmpID2,
+                        Prcb->CpuType,
+                        (Prcb->CpuStep >> 8),
+                        Prcb->CpuStep & 0xff);
+            }
+
+            /* Save the ID string length now that we've created it */
+            ConfigData.ComponentEntry.IdentifierLength = strlen(Buffer) + 1;
+
+            /* Initialize the registry configuration node for it */
+            Status = CmpInitializeRegistryNode(&ConfigData,
+                                               SystemHandle,
+                                               &KeyHandle,
+                                               InterfaceTypeUndefined,
+                                               0xFFFFFFFF,
+                                               IndexTable);
+            if (!NT_SUCCESS(Status)) return(Status);
+
+            {
+                /* Setup the Configuration Entry for the FPU */
+                RtlZeroMemory(&ConfigData, sizeof(ConfigData));
+                ConfigData.ComponentEntry.Class = ProcessorClass;
+                ConfigData.ComponentEntry.Type = FloatingPointProcessor;
+                ConfigData.ComponentEntry.Key = i;
+                ConfigData.ComponentEntry.AffinityMask = AFFINITY_MASK(i);
+                ConfigData.ComponentEntry.Identifier = Buffer;
+
+                /* For 386 cpus, the CPU pp is the identifier */
+                if (Prcb->CpuType == 3) strcpy(Buffer, "80387");
+
+                /* Save the ID string length now that we've created it */
+                ConfigData.ComponentEntry.IdentifierLength = strlen(Buffer) + 1;
+
+                /* Initialize the registry configuration node for it */
+                Status = CmpInitializeRegistryNode(&ConfigData,
+                                                   SystemHandle,
+                                                   &FpuHandle,
+                                                   InterfaceTypeUndefined,
+                                                   0xFFFFFFFF,
+                                                   IndexTable);
+                if (!NT_SUCCESS(Status))
+                {
+                    /* Failed, close the CPU handle and return */
+                    NtClose(KeyHandle);
+                    return Status;
+                }
+
+                /* Close this new handle */
+                NtClose(FpuHandle);
+
+                /* Stay on this CPU only */
+                KeSetSystemAffinityThread(Prcb->SetMember);
+                if (!Prcb->CpuID)
+                {
+                    /* Uh oh, no CPUID! */
+                }
+                else
+                {
+                    /* Check if we have extended CPUID that supports name ID */
+                    //Ki386Cpuid(0x80000000, &ExtendedId, &Dummy, &Dummy, &Dummy);
+                    if (ExtendedId >= 0x80000004)
+                    {
+                        /* Do all the CPUIDs requred to get the full name */
+                        PartialString = CpuString;
+                        for (ExtendedId = 2; ExtendedId <= 4; ExtendedId++)
+                        {
+#if 0
+                            /* Do the CPUID and save the name string */
+                            Ki386Cpuid(0x80000000 | ExtendedId,
+                                       (PULONG)PartialString,
+                                       (PULONG)PartialString + 1,
+                                       (PULONG)PartialString + 2,
+                                       (PULONG)PartialString + 3);
+#endif
+
+                            /* Go to the next name string */
+                            PartialString += 16;
+                        }
+
+                        /* Null-terminate it */
+                        CpuString[48] = ANSI_NULL;
+                    }
+                }
+
+                /* Get the cache size while we're still localized */
+                CacheSize = 0; //((PKIPCR)KeGetPcr())->SecondLevelCacheSize;
+
+                /* Go back to user affinity */
+                KeRevertToUserAffinityThread();
+
+                /* Check if we have a CPU Name */
+                if (PartialString)
+                {
+                    /* Convert it to Unicode */
+                    RtlInitAnsiString(&TempString, CpuString);
+                    RtlAnsiStringToUnicodeString(&Data, &TempString, TRUE);
+
+                    /* Add it to the registry */
+                    RtlInitUnicodeString(&ValueName, L"ProcessorNameString");
+                    Status = NtSetValueKey(KeyHandle,
+                                           &ValueName,
+                                           0,
+                                           REG_SZ,
+                                           Data.Buffer,
+                                           Data.Length + sizeof(UNICODE_NULL));
+
+                    /* ROS: Save a copy for bugzilla reporting */
+                    RtlCreateUnicodeString(&KeRosProcessorName, Data.Buffer);
+                    
+                    /* Free the temporary buffer */
+                    RtlFreeUnicodeString(&Data);
+                }
+
+                /* Check if we had a Vendor ID */
+                if (Prcb->VendorString)
+                {
+                    /* Convert it to Unicode */
+                    RtlInitAnsiString(&TempString, Prcb->VendorString);
+                    RtlAnsiStringToUnicodeString(&Data, &TempString, TRUE);
+
+                    /* Add it to the registry */
+                    RtlInitUnicodeString(&ValueName, L"VendorIdentifier");
+                    Status = NtSetValueKey(KeyHandle,
+                                           &ValueName,
+                                           0,
+                                           REG_SZ,
+                                           Data.Buffer,
+                                           Data.Length + sizeof(UNICODE_NULL));
+                    
+                    /* Free the temporary buffer */
+                    RtlFreeUnicodeString(&Data);
+                }
+
+                /* Check if we have features bits */
+                if (Prcb->FeatureBits)
+                {
+                    /* Add them to the registry */
+                    RtlInitUnicodeString(&ValueName, L"FeatureSet");
+                    Status = NtSetValueKey(KeyHandle,
+                                           &ValueName,
+                                           0,
+                                           REG_DWORD,
+                                           &Prcb->FeatureBits,
+                                           sizeof(Prcb->FeatureBits));
+                }
+
+                /* Check if we detected the CPU Speed */
+                if (Prcb->MHz)
+                {
+                    /* Add it to the registry */
+                    RtlInitUnicodeString(&ValueName, L"~MHz");
+                    Status = NtSetValueKey(KeyHandle,
+                                           &ValueName,
+                                           0,
+                                           REG_DWORD,
+                                           &Prcb->MHz,
+                                           sizeof(Prcb->MHz));
+                }
+
+                /* Check if we have an update signature */
+                if (Prcb->UpdateSignature.QuadPart)
+                {
+                    /* Add it to the registry */
+                    RtlInitUnicodeString(&ValueName, L"Update Signature");
+                    Status = NtSetValueKey(KeyHandle,
+                                           &ValueName,
+                                           0,
+                                           REG_BINARY,
+                                           &Prcb->UpdateSignature,
+                                           sizeof(Prcb->UpdateSignature));
+                }
+
+                /* Close the processor handle */
+                NtClose(KeyHandle);
+
+                /* FIXME: Detect CPU mismatches */
+            }
+        }
+
+        /* Free the configuration data */
+        ExFreePool(CmpConfigurationData);
+    }
+
+    /* Open physical memory */
+    RtlInitUnicodeString(&SectionName, L"\\Device\\PhysicalMemory");
+    InitializeObjectAttributes(&ObjectAttributes,
+                               &SectionName,
+                               OBJ_CASE_INSENSITIVE,
+                               NULL,
+                               NULL);
+    Status = ZwOpenSection(&SectionHandle,
+                           SECTION_ALL_ACCESS,
+                           &ObjectAttributes);
+    if (!NT_SUCCESS(Status)) goto Quickie;
+
+    /* Map the first 1KB of memory to get the IVT */
+    ViewSize = PAGE_SIZE;
+    Status = ZwMapViewOfSection(SectionHandle,
+                                NtCurrentProcess(),
+                                &BaseAddress,
+                                0,
+                                ViewSize,
+                                &ViewBase,
+                                &ViewSize,
+                                ViewUnmap,
+                                MEM_DOS_LIM,
+                                PAGE_READWRITE);
+    if (!NT_SUCCESS(Status))
+    {
+        /* Assume default */
+        VideoRomBase = 0xC0000;
+    }
+    else
+    {
+        /* Calculate the base address from the vector */
+        VideoRomBase = (*((PULONG)BaseAddress + 0x10) >> 12) & 0xFFFF0;
+        VideoRomBase += *((PULONG)BaseAddress + 0x10) & 0xFFF0;
+
+        /* Now get to the actual ROM Start and make sure it's not invalid*/
+        VideoRomBase &= 0xFFFF8000;
+        if (VideoRomBase < 0xC0000) VideoRomBase = 0xC0000;
+
+        /* And unmap the section */
+        ZwUnmapViewOfSection(NtCurrentProcess(), BaseAddress);
+    }
+
+    /* Allocate BIOS Version pp Buffer */
+    BiosVersion = ExAllocatePoolWithTag(PagedPool, PAGE_SIZE, TAG_CM);
+
+    /* Setup settings to map the 64K BIOS ROM */
+    BaseAddress = 0;
+    ViewSize = 16 * PAGE_SIZE;
+    ViewBase.LowPart = 0xF0000;
+    ViewBase.HighPart = 0;
+
+    /* Map it */
+    Status = ZwMapViewOfSection(SectionHandle,
+                                NtCurrentProcess(),
+                                &BaseAddress,
+                                0,
+                                ViewSize,
+                                &ViewBase,
+                                &ViewSize,
+                                ViewUnmap,
+                                MEM_DOS_LIM,
+                                PAGE_READWRITE);
+    if (NT_SUCCESS(Status))
+    {
+        /* Scan the ROM to get the BIOS Date */
+        if (CmpGetBiosDate(BaseAddress, 16 * PAGE_SIZE, Buffer, TRUE))
+        {
+            /* Convert it to Unicode */
+            RtlInitAnsiString(&TempString, Buffer);
+            RtlAnsiStringToUnicodeString(&Data, &TempString, TRUE);
+
+            /* Write the date into the registry */
+            RtlInitUnicodeString(&ValueName, L"SystemBiosDate");
+            Status = NtSetValueKey(SystemHandle,
+                                   &ValueName,
+                                   0,
+                                   REG_SZ,
+                                   Data.Buffer,
+                                   Data.Length + sizeof(UNICODE_NULL));
+
+            /* Free the string */
+            RtlFreeUnicodeString(&Data);
+
+            if (BiosHandle)
+            {
+                /* Get the BIOS Date Identifier */
+                RtlCopyMemory(Buffer, (PCHAR)BaseAddress + (16*PAGE_SIZE - 11), 8);
+                Buffer[8] = ANSI_NULL;
+
+                /* Convert it to unicode */
+                RtlInitAnsiString(&TempString, Buffer);
+                Status = RtlAnsiStringToUnicodeString(&Data, &TempString, TRUE);
+                if (NT_SUCCESS(Status))
+                {
+                    /* Save it to the registry */
+                    Status = NtSetValueKey(BiosHandle,
+                                           &ValueName,
+                                           0,
+                                           REG_SZ,
+                                           Data.Buffer,
+                                           Data.Length + sizeof(UNICODE_NULL));
+                    
+                    /* ROS: Save a copy for bugzilla reporting */
+                    RtlCreateUnicodeString(&KeRosBiosDate, Data.Buffer);
+
+                    /* Free the string */
+                    RtlFreeUnicodeString(&Data);
+                }
+
+                /* Close the bios information handle */
+                NtClose(BiosHandle);
+            }
+        }
+
+        /* Get the BIOS Version */
+        if (CmpGetBiosVersion(BaseAddress, 16* PAGE_SIZE, Buffer))
+        {
+            /* Start at the beginning of our buffer */
+            CurrentVersion = BiosVersion;
+            do
+            {
+                /* Convert to Unicode */
+                RtlInitAnsiString(&TempString, Buffer);
+                RtlAnsiStringToUnicodeString(&Data, &TempString, TRUE);
+
+                /* Calculate the length of this string and copy it in */
+                Length = Data.Length + sizeof(UNICODE_NULL);
+                RtlMoveMemory(CurrentVersion, Data.Buffer, Length);
+
+                /* Free the unicode string */
+                RtlFreeUnicodeString(&Data);
+
+                /* Update the total length and see if we're out of space */
+                TotalLength += Length;
+                if (TotalLength + 256 + sizeof(UNICODE_NULL) > PAGE_SIZE)
+                {
+                    /* One more string would push us out, so stop here */
+                    break;
+                }
+
+                /* Go to the next string inside the multi-string buffer */
+                CurrentVersion += Length;
+
+                /* Query the next BIOS Version */
+            } while (CmpGetBiosVersion(NULL, 0, Buffer));
+
+            /* Check if we found any strings at all */
+            if (TotalLength)
+            {
+                /* Add the final null-terminator */
+                *(PWSTR)CurrentVersion = UNICODE_NULL;
+                TotalLength += sizeof(UNICODE_NULL);
+
+                /* Write the BIOS Version to the registry */
+                RtlInitUnicodeString(&ValueName, L"SystemBiosVersion");
+                Status = NtSetValueKey(SystemHandle,
+                                       &ValueName,
+                                       0,
+                                       REG_MULTI_SZ,
+                                       BiosVersion,
+                                       TotalLength);
+                
+                /* ROS: Save a copy for bugzilla reporting */
+                RtlCreateUnicodeString(&KeRosBiosVersion, (PWCH)BiosVersion);
+            }
+        }
+
+        /* Unmap the section */
+        ZwUnmapViewOfSection(NtCurrentProcess(), BaseAddress);
+    }
+
+    /* Now prepare for Video BIOS Mapping of 32KB */
+    BaseAddress = 0;
+    ViewSize = 8 * PAGE_SIZE;
+    ViewBase.LowPart = VideoRomBase;
+    ViewBase.HighPart = 0;
+
+    /* Map it */
+    Status = ZwMapViewOfSection(SectionHandle,
+                                NtCurrentProcess(),
+                                &BaseAddress,
+                                0,
+                                ViewSize,
+                                &ViewBase,
+                                &ViewSize,
+                                ViewUnmap,
+                                MEM_DOS_LIM,
+                                PAGE_READWRITE);
+    if (NT_SUCCESS(Status))
+    {
+        /* Scan the ROM to get the BIOS Date */
+        if (CmpGetBiosDate(BaseAddress, 8 * PAGE_SIZE, Buffer, FALSE))
+        {
+            /* Convert it to Unicode */
+            RtlInitAnsiString(&TempString, Buffer);
+            RtlAnsiStringToUnicodeString(&Data, &TempString, TRUE);
+
+            /* Write the date into the registry */
+            RtlInitUnicodeString(&ValueName, L"VideoBiosDate");
+            Status = NtSetValueKey(SystemHandle,
+                                   &ValueName,
+                                   0,
+                                   REG_SZ,
+                                   Data.Buffer,
+                                   Data.Length + sizeof(UNICODE_NULL));
+            
+            /* ROS: Save a copy for bugzilla reporting */
+            RtlCreateUnicodeString(&KeRosVideoBiosDate, Data.Buffer);
+
+            /* Free the string */
+            RtlFreeUnicodeString(&Data);
+        }
+
+        /* Get the Video BIOS Version */
+        if (CmpGetBiosVersion(BaseAddress, 8* PAGE_SIZE, Buffer))
+        {
+            /* Start at the beginning of our buffer */
+            CurrentVersion = BiosVersion;
+            do
+            {
+                /* Convert to Unicode */
+                RtlInitAnsiString(&TempString, Buffer);
+                RtlAnsiStringToUnicodeString(&Data, &TempString, TRUE);
+
+                /* Calculate the length of this string and copy it in */
+                Length = Data.Length + sizeof(UNICODE_NULL);
+                RtlMoveMemory(CurrentVersion, Data.Buffer, Length);
+
+                /* Free the unicode string */
+                RtlFreeUnicodeString(&Data);
+
+                /* Update the total length and see if we're out of space */
+                TotalLength += Length;
+                if (TotalLength + 256 + sizeof(UNICODE_NULL) > PAGE_SIZE)
+                {
+                    /* One more string would push us out, so stop here */
+                    break;
+                }
+
+                /* Go to the next string inside the multi-string buffer */
+                CurrentVersion += Length;
+
+                /* Query the next BIOS Version */
+            } while (CmpGetBiosVersion(NULL, 0, Buffer));
+
+            /* Check if we found any strings at all */
+            if (TotalLength)
+            {
+                /* Add the final null-terminator */
+                *(PWSTR)CurrentVersion = UNICODE_NULL;
+                TotalLength += sizeof(UNICODE_NULL);
+
+                /* Write the BIOS Version to the registry */
+                RtlInitUnicodeString(&ValueName, L"VideoBiosVersion");
+                Status = NtSetValueKey(SystemHandle,
+                                       &ValueName,
+                                       0,
+                                       REG_MULTI_SZ,
+                                       BiosVersion,
+                                       TotalLength);
+                
+                /* ROS: Save a copy for bugzilla reporting */
+                RtlCreateUnicodeString(&KeRosVideoBiosVersion, (PWCH)BiosVersion);
+            }
+        }
+
+        /* Unmap the section */
+        ZwUnmapViewOfSection(NtCurrentProcess(), BaseAddress);
+    }
+
+    /* Close the section */
+    ZwClose(SectionHandle);
+
+    /* Free the BIOS version string buffer */
+    if (BiosVersion) ExFreePool(BiosVersion);
+
+Quickie:
+    /* Close the procesor handle */
+    NtClose(KeyHandle);
+    return STATUS_SUCCESS;
+}
diff --git a/reactos/ntoskrnl/ex/powerpc/fastinterlck.c b/reactos/ntoskrnl/ex/powerpc/fastinterlck.c
new file mode 100644
index 00000000000..4f8fccb8f4c
--- /dev/null
+++ b/reactos/ntoskrnl/ex/powerpc/fastinterlck.c
@@ -0,0 +1,262 @@
+/*
+ * PROJECT:         ReactOS Kernel
+ * COPYRIGHT:       GPL - See COPYING in the top level directory
+ * FILE:            ntoskrnl/ex/powerpc/fastinterlck.c
+ * PURPOSE:         Executive Atom Functions
+ * PROGRAMMERS:     Art Yerkes
+ */
+
+/* INCLUDES *****************************************************************/
+
+#include <ntoskrnl.h>
+#include <internal/debug.h>
+
+NTKERNELAPI
+PSINGLE_LIST_ENTRY
+FASTCALL
+ExInterlockedFlushSList(IN PSLIST_HEADER  ListHead)
+{
+    PSLIST_ENTRY NewHead = NULL;
+    _InterlockedExchangePointer((PVOID *)&ListHead->Next.Next, &NewHead);
+    return NewHead;
+}
+
+#undef ExInterlockedPushEntrySList
+NTKERNELAPI
+PSLIST_ENTRY
+FASTCALL
+ExInterlockedPushEntrySList
+(IN PSLIST_HEADER  ListHead,
+ IN PSLIST_ENTRY  ListEntry)
+{
+    return InterlockedPushEntrySList(ListHead, ListEntry);
+}
+
+#undef ExInterlockedPopEntrySList
+NTKERNELAPI
+PSINGLE_LIST_ENTRY
+NTAPI
+ExInterlockedPopEntrySList(
+  IN PSLIST_HEADER  ListHead,
+  IN PKSPIN_LOCK  Lock)
+{
+    return InterlockedPopEntrySList(ListHead);
+}
+
+#undef ExInterlockedAddULong
+NTKERNELAPI
+ULONG
+NTAPI
+ExfInterlockedAddUlong(
+  IN PULONG  Addend,
+  IN ULONG  Increment,
+  PKSPIN_LOCK  Lock)
+{
+    KIRQL OldIrql;
+    KeAcquireSpinLock(Lock, &OldIrql);
+    *Addend += Increment;
+    KeReleaseSpinLock(Lock, OldIrql);
+    return *Addend;
+}
+
+NTKERNELAPI
+LONGLONG
+FASTCALL
+ExfInterlockedCompareExchange64(
+  IN OUT LONGLONG volatile  *Destination,
+  IN PLONGLONG  Exchange,
+  IN PLONGLONG  Comperand)
+{
+    return 0ll;
+}
+
+NTKERNELAPI
+PLIST_ENTRY
+FASTCALL
+ExfInterlockedInsertHeadList(
+  IN PLIST_ENTRY  ListHead,
+  IN PLIST_ENTRY  ListEntry,
+  IN PKSPIN_LOCK  Lock)
+{
+    return NULL;
+}
+
+NTKERNELAPI
+PLIST_ENTRY
+FASTCALL
+ExfInterlockedInsertTailList(
+  IN PLIST_ENTRY  ListHead,
+  IN PLIST_ENTRY  ListEntry,
+  IN PKSPIN_LOCK  Lock)
+{
+    return NULL;
+}
+
+NTKERNELAPI
+PSINGLE_LIST_ENTRY
+FASTCALL
+ExfInterlockedPopEntryList(
+  IN PSINGLE_LIST_ENTRY  ListHead,
+  IN PKSPIN_LOCK  Lock)
+{
+    return NULL;
+}
+
+NTKERNELAPI
+PSINGLE_LIST_ENTRY
+FASTCALL
+ExfInterlockedPushEntryList(
+  IN PSINGLE_LIST_ENTRY  ListHead,
+  IN PSINGLE_LIST_ENTRY  ListEntry,
+  IN PKSPIN_LOCK  Lock)
+{
+    return NULL;
+}
+
+NTKERNELAPI
+PLIST_ENTRY
+FASTCALL
+ExfInterlockedRemoveHeadList(
+  IN PLIST_ENTRY  ListHead,
+  IN PKSPIN_LOCK  Lock)
+{
+    return ExInterlockedRemoveHeadList(ListHead, Lock);
+}
+
+NTKERNELAPI
+INTERLOCKED_RESULT
+FASTCALL
+Exfi386InterlockedIncrementLong(
+  IN PLONG  Addend)
+{
+    return 0;
+}
+
+NTKERNELAPI
+INTERLOCKED_RESULT
+FASTCALL
+Exfi386InterlockedDecrementLong(
+  IN PLONG  Addend)
+{
+    return 0;
+}
+
+NTKERNELAPI
+ULONG
+FASTCALL
+Exfi386InterlockedExchangeUlong(
+  IN PULONG  Target,
+  IN ULONG  Value)
+{
+    return 0;
+}
+
+NTKERNELAPI
+LARGE_INTEGER
+NTAPI
+ExInterlockedAddLargeInteger(
+  IN PLARGE_INTEGER  Addend,
+  IN LARGE_INTEGER  Increment,
+  IN PKSPIN_LOCK  Lock)
+{
+    LARGE_INTEGER Result;
+    Result.QuadPart = 0;
+    return Result;
+}
+
+NTKERNELAPI
+ULONG
+NTAPI
+ExInterlockedAddUlong(
+  IN PULONG  Addend,
+  IN ULONG  Increment,
+  PKSPIN_LOCK  Lock)
+{
+    return 0;
+}
+
+#undef ExInterlockedIncrementLong
+NTKERNELAPI
+INTERLOCKED_RESULT
+NTAPI
+ExInterlockedIncrementLong(
+    IN PLONG  Addend, 
+    IN PKSPIN_LOCK Lock)
+{
+    return 0;
+}
+
+#undef ExInterlockedDecrementLong
+NTKERNELAPI
+INTERLOCKED_RESULT
+NTAPI
+ExInterlockedDecrementLong(
+    IN PLONG  Addend,
+    IN PKSPIN_LOCK Lock)
+{
+    return 0;
+}
+
+NTKERNELAPI
+ULONG
+NTAPI
+ExInterlockedExchangeUlong(
+  IN PULONG  Target,
+  IN ULONG  Value,
+  IN PKSPIN_LOCK Lock)
+{
+    return 0;
+}
+
+NTKERNELAPI
+PLIST_ENTRY
+NTAPI
+ExInterlockedInsertHeadList(
+  IN PLIST_ENTRY  ListHead,
+  IN PLIST_ENTRY  ListEntry,
+  IN PKSPIN_LOCK  Lock)
+{
+    return NULL;
+}
+
+NTKERNELAPI
+PLIST_ENTRY
+NTAPI
+ExInterlockedInsertTailList(
+  IN PLIST_ENTRY  ListHead,
+  IN PLIST_ENTRY  ListEntry,
+  IN PKSPIN_LOCK  Lock)
+{
+    return NULL;
+}
+
+NTKERNELAPI
+PSINGLE_LIST_ENTRY
+NTAPI
+ExInterlockedPopEntryList(
+  IN PSINGLE_LIST_ENTRY  ListHead,
+  IN PKSPIN_LOCK  Lock)
+{
+    return NULL;
+}
+
+NTKERNELAPI
+PSINGLE_LIST_ENTRY
+NTAPI
+ExInterlockedPushEntryList(
+  IN PSINGLE_LIST_ENTRY  ListHead,
+  IN PSINGLE_LIST_ENTRY  ListEntry,
+  IN PKSPIN_LOCK  Lock)
+{
+    return NULL;
+}
+
+NTKERNELAPI
+PLIST_ENTRY
+NTAPI
+ExInterlockedRemoveHeadList(
+  IN PLIST_ENTRY  ListHead,
+  IN PKSPIN_LOCK  Lock)
+{
+    return NULL;
+}
diff --git a/reactos/ntoskrnl/ex/powerpc/ioport.s b/reactos/ntoskrnl/ex/powerpc/ioport.s
new file mode 100644
index 00000000000..b14f0780500
--- /dev/null
+++ b/reactos/ntoskrnl/ex/powerpc/ioport.s
@@ -0,0 +1,171 @@
+/*
+ * COPYRIGHT:       See COPYING in the top level directory
+ * PROJECT:         ReactOS kernel
+ * FILE:            ntoskrnl/ex/i386/ioport.S
+ * PURPOSE:         FASTCALL Interlocked Functions
+ * PROGRAMMERS:     Alex Ionescu (alex@relsoft.net)
+ */
+
+/* INCLUDES ******************************************************************/
+
+#include <ndk/asm.h>
+
+/* GLOBALS *******************************************************************/
+
+.globl READ_REGISTER_UCHAR
+.globl READ_REGISTER_USHORT
+.globl READ_REGISTER_ULONG
+.globl READ_REGISTER_BUFFER_UCHAR
+.globl READ_REGISTER_BUFFER_USHORT
+.globl READ_REGISTER_BUFFER_ULONG
+.globl WRITE_REGISTER_UCHAR
+.globl WRITE_REGISTER_USHORT
+.globl WRITE_REGISTER_ULONG
+.globl WRITE_REGISTER_BUFFER_UCHAR
+.globl WRITE_REGISTER_BUFFER_USHORT
+.globl WRITE_REGISTER_BUFFER_ULONG
+
+/* FUNCTIONS *****************************************************************/
+
+READ_REGISTER_UCHAR:
+        /* Return the requested memory location */
+        sync
+        eieio
+        lbz 3,0(3)
+        blr
+
+READ_REGISTER_USHORT:
+        /* Return the requested memory location */
+        sync
+        eieio
+        lhz 3,0(3)
+        blr
+
+READ_REGISTER_ULONG:    
+        /* Return the requested memory location */
+        sync
+        eieio
+        lwz 3,0(3)
+        blr
+
+READ_REGISTER_BUFFER_UCHAR:
+1:      
+        cmpwi 0,5,0
+        beq 2f
+
+        lbz 0,0(4)
+        stb 0,0(3)
+        
+        addi 3,3,1
+        addi 4,4,1
+        subi 5,5,1
+        b 1b
+2:
+        eieio
+        sync
+        blr
+        
+READ_REGISTER_BUFFER_USHORT:    
+1:      
+        cmpwi 0,5,0
+        beq 2f
+
+        lhz 0,0(4)
+        sth 0,0(3)
+        
+        addi 3,3,2
+        addi 4,4,2
+        subi 5,5,2
+        b 1b
+2:
+        eieio
+        sync
+        blr
+
+READ_REGISTER_BUFFER_ULONG:
+1:      
+        cmpwi 0,5,0
+        beq 2f
+
+        lwz 0,0(4)
+        stw 0,0(3)
+        
+        addi 3,3,4
+        addi 4,4,4
+        subi 5,5,4
+        b 1b
+2:
+        eieio
+        sync
+        blr
+
+WRITE_REGISTER_UCHAR:
+        stb 4,0(3)
+        eieio
+        sync
+        blr
+
+WRITE_REGISTER_USHORT:
+        sth 4,0(3)
+        eieio
+        sync
+        blr
+        
+WRITE_REGISTER_ULONG:
+        stw 4,0(3)
+        eieio
+        sync
+        blr
+
+WRITE_REGISTER_BUFFER_UCHAR:
+        sync
+        eieio
+1:      
+        cmpwi 0,5,0
+        beq 2f
+
+        lbz 0,0(4)
+        stb 0,0(3)
+        
+        addi 3,3,1
+        addi 4,4,1
+        subi 5,5,1
+        b 1b
+2:
+        blr
+
+WRITE_REGISTER_BUFFER_USHORT:
+        sync
+        eieio
+1:      
+        cmpwi 0,5,0
+        beq 2f
+
+        lhz 0,0(4)
+        sth 0,0(3)
+        
+        addi 3,3,2
+        addi 4,4,2
+        subi 5,5,2
+        b 1b
+2:
+        blr
+
+WRITE_REGISTER_BUFFER_ULONG:
+        sync
+        eieio
+1:      
+        cmpwi 0,5,0
+        beq 2f
+
+        lwz 0,0(4)
+        stw 0,0(3)
+        
+        addi 3,3,4
+        addi 4,4,4
+        subi 5,5,4
+        b 1b
+2:
+        blr
+
+/* EOF */
diff --git a/reactos/ntoskrnl/ex/sysinfo.c b/reactos/ntoskrnl/ex/sysinfo.c
index 3343295d11e..a13f1d288d0 100644
--- a/reactos/ntoskrnl/ex/sysinfo.c
+++ b/reactos/ntoskrnl/ex/sysinfo.c
@@ -1923,7 +1923,7 @@ NtFlushInstructionCache (
 #if defined(_M_IX86)
     __wbinvd();
 #elif defined(_M_PPC)
-#error Needs to be implemented for PPC architecture!
+    __asm__ __volatile__("tlbsync");
 #elif defined(_M_MIPS)
     DPRINT1("NtFlushInstructionCache() is not implemented\n");
     for (;;);
diff --git a/reactos/ntoskrnl/include/internal/i386/intrin_i.h b/reactos/ntoskrnl/include/internal/i386/intrin_i.h
index 6c963a9cee6..756a6b7604d 100644
--- a/reactos/ntoskrnl/include/internal/i386/intrin_i.h
+++ b/reactos/ntoskrnl/include/internal/i386/intrin_i.h
@@ -412,6 +412,9 @@ Ke386SetEs(IN USHORT Value)
 #error Unknown compiler for inline assembler
 #endif
 
+#define KeArchFnInit() Ke386FnInit()
+#define KeArchHaltProcessor() Ke386HaltProcessor()
+
 #endif
 
 /* EOF */
diff --git a/reactos/ntoskrnl/include/internal/kd.h b/reactos/ntoskrnl/include/internal/kd.h
index 2f0e315699b..053205ae529 100644
--- a/reactos/ntoskrnl/include/internal/kd.h
+++ b/reactos/ntoskrnl/include/internal/kd.h
@@ -1,6 +1,11 @@
 #ifndef __INCLUDE_INTERNAL_KERNEL_DEBUGGER_H
 #define __INCLUDE_INTERNAL_KERNEL_DEBUGGER_H
 
+#ifdef _M_PPC
+#define KdDebuggerEnabled _KdDebuggerEnabled
+#define KdDebuggerNotPresent _KdDebuggerNotPresent
+#endif
+
 //
 // Kernel Debugger Port Definition
 //
diff --git a/reactos/ntoskrnl/include/internal/ke_x.h b/reactos/ntoskrnl/include/internal/ke_x.h
index e81ed7e1693..46714d395a7 100644
--- a/reactos/ntoskrnl/include/internal/ke_x.h
+++ b/reactos/ntoskrnl/include/internal/ke_x.h
@@ -355,7 +355,7 @@ KiRundownThread(IN PKTHREAD Thread)
     {
         /* Clear it */
         KeGetCurrentPrcb()->NpxThread = NULL;
-        Ke386FnInit();
+        KeArchFnInit();
     }
 }
 
@@ -1529,7 +1529,11 @@ FORCEINLINE
 KeGetCurrentThread(VOID)
 {
     /* Return the current thread */
+#ifdef _M_PPC
+    return ((PKIPCR)KeGetPcr())->PrcbData->CurrentThread;
+#else
     return ((PKIPCR)KeGetPcr())->PrcbData.CurrentThread;
+#endif
 }
 
 UCHAR
@@ -1545,6 +1549,10 @@ FORCEINLINE
 KeFlushProcessTb(VOID)
 {
     /* Flush the TLB by resetting CR3 */
+#ifdef _M_PPC
+    __asm__("sync\n\tisync\n\t");
+#else
     __writecr3(__readcr3());
+#endif
 }
 
diff --git a/reactos/ntoskrnl/include/internal/ntoskrnl.h b/reactos/ntoskrnl/include/internal/ntoskrnl.h
index d1062a0328c..236d3bf124d 100644
--- a/reactos/ntoskrnl/include/internal/ntoskrnl.h
+++ b/reactos/ntoskrnl/include/internal/ntoskrnl.h
@@ -281,7 +281,7 @@ DefaultQueryInfoBufferCheck(ULONG Class,
  * Use IsPointerOffset to test whether a pointer should be interpreted as an offset
  * or as a pointer
  */
-#if defined(_X86_) || defined(_M_AMD64) || defined(_MIPS_)
+#if defined(_X86_) || defined(_M_AMD64) || defined(_MIPS_) || defined(_PPC_)
 
 /* for x86 and x86-64 the MSB is 1 so we can simply test on that */
 #define IsPointerOffset(Ptr) ((LONG_PTR)(Ptr) >= 0)
@@ -314,6 +314,7 @@ C_ASSERT(FIELD_OFFSET(KPROCESS, DirectoryTableBase) == KPROCESS_DIRECTORY_TABLE_
 C_ASSERT(FIELD_OFFSET(KPCR, IRR) == KPCR_IRR);
 C_ASSERT(FIELD_OFFSET(KPCR, IDR) == KPCR_IDR);
 C_ASSERT(FIELD_OFFSET(KPCR, Irql) == KPCR_IRQL);
+#ifdef _M_IX86
 C_ASSERT(FIELD_OFFSET(KIPCR, PrcbData) + FIELD_OFFSET(KPRCB, CurrentThread) == KPCR_CURRENT_THREAD);
 C_ASSERT(FIELD_OFFSET(KIPCR, PrcbData) + FIELD_OFFSET(KPRCB, NextThread) == KPCR_PRCB_NEXT_THREAD);
 C_ASSERT(FIELD_OFFSET(KIPCR, PrcbData) + FIELD_OFFSET(KPRCB, NpxThread) == KPCR_NPX_THREAD);
@@ -337,7 +338,6 @@ C_ASSERT(FIELD_OFFSET(KIPCR, PrcbData) + FIELD_OFFSET(KPRCB, DpcStack) == KPCR_P
 C_ASSERT(sizeof(FX_SAVE_AREA) == SIZEOF_FX_SAVE_AREA);
 
 /* Platform specific checks */
-#ifdef _M_IX86
 C_ASSERT(FIELD_OFFSET(KPROCESS, IopmOffset) == KPROCESS_IOPM_OFFSET);
 C_ASSERT(FIELD_OFFSET(KPROCESS, LdtDescriptor) == KPROCESS_LDT_DESCRIPTOR0);
 C_ASSERT(FIELD_OFFSET(KV86M_TRAP_FRAME, SavedExceptionStack) == TF_SAVED_EXCEPTION_STACK);
diff --git a/reactos/ntoskrnl/include/internal/powerpc/intrin_i.h b/reactos/ntoskrnl/include/internal/powerpc/intrin_i.h
index c5ba0381421..025cf21f67e 100644
--- a/reactos/ntoskrnl/include/internal/powerpc/intrin_i.h
+++ b/reactos/ntoskrnl/include/internal/powerpc/intrin_i.h
@@ -1,6 +1,8 @@
 #ifndef _INTRIN_INTERNAL_
 #define _INTRIN_INTERNAL_
 
+#define Ke386SaveFlags(x) __asm__ __volatile__("mfmsr %0" : "=r" (x) :)
+
 #endif
 
 /* EOF */
diff --git a/reactos/ntoskrnl/include/internal/powerpc/ke.h b/reactos/ntoskrnl/include/internal/powerpc/ke.h
index a2973609ff5..1ba8c5a6c0d 100644
--- a/reactos/ntoskrnl/include/internal/powerpc/ke.h
+++ b/reactos/ntoskrnl/include/internal/powerpc/ke.h
@@ -19,11 +19,14 @@
 #ifndef __NTOSKRNL_INCLUDE_INTERNAL_POWERPC_KE_H
 #define __NTOSKRNL_INCLUDE_INTERNAL_POWERPC_KE_H
 
+#include <ndk/powerpc/ketypes.h>
+
 #if __GNUC__ >=3
 #pragma GCC system_header
 #endif
 
 /* Possible values for KTHREAD's NpxState */
+#define KPCR_BASE 0xff000000
 #define NPX_STATE_INVALID   0x01
 #define NPX_STATE_VALID     0x02
 #define NPX_STATE_DIRTY     0x04
@@ -107,7 +110,7 @@ static inline LONG KePPCTestAndSetBit(ULONG BitPos, volatile PULONG Addr)
     return NewValue & (1 << BitPos);
 }
 
-#define KePPCRdmsr(msr,val1,val2) __asm__ __volatile__("mfmsr 2")
+#define KePPCRdmsr(msr,val1,val2) __asm__ __volatile__("mfmsr 3")
 
 #define KePPCWrmsr(msr,val1,val2) __asm__ __volatile__("mtmsr 3")
 
@@ -120,17 +123,65 @@ __asm__ __volatile__("mfmsr 0\n\t" \
 
 #define KePPCEnableInterrupts() \
  __asm__ __volatile__("mfmsr 0\n\t" \
-                      "li    8,0x8000\n\t" \
+                      "lis    8,0x8000@ha\n\t" \
                       "or    0,8,0\n\t" \
                       "mtmsr 0\n\t")
 
-#define KePPCHaltProcessor()     ;
-
-#endif /* __ASM__ */
+#define KePPCHaltProcessor()     
 
 #define KeArchEraseFlags()
 #define KeArchDisableInterrupts() KePPCDisableInterrupts()
 
+#define PPC_MIN_CACHE_LINE_SIZE 32
+
+FORCEINLINE struct _KPCR * NTHALAPI KeGetCurrentKPCR(
+    VOID)
+{
+    return (struct _KPCR *)__readfsdword(0x1c);
+}
+
+VOID
+STDCALL
+KePPCInitThreadWithContext(
+	PKTHREAD Thread,
+	PKSYSTEM_ROUTINE SystemRoutine,
+	PKSTART_ROUTINE StartRoutine,
+	PVOID StartContext,
+	PCONTEXT Context);
+
+VOID
+STDCALL
+KeApplicationProcessorInitDispatcher(
+  VOID);
+
+VOID
+STDCALL
+KeCreateApplicationProcessorIdleThread(
+  ULONG Id);
+
+static VOID KePPCFnInit() 
+{
+    __asm__("mfmsr 0\n\tori 0,0,0x2000\n\tmtmsr 0");
+}
+
+#ifdef _NTOSKRNL_ /* FIXME: Move flags above to NDK instead of here */
+VOID
+STDCALL
+KiThreadStartup(PKSYSTEM_ROUTINE SystemRoutine,
+                PKSTART_ROUTINE StartRoutine,
+                PVOID StartContext,
+                BOOLEAN UserThread,
+                KTRAP_FRAME TrapFrame);
+#endif
+VOID 
+NTAPI 
+KiSaveProcessorControlState(OUT PKPROCESSOR_STATE ProcessorState);
+
+#endif /* __ASM__ */
+
+#define KeArchFnInit() KePPCFnInit()
+#define KeArchHaltProcessor() KePPCHaltProcessor()
+
 #endif /* __NTOSKRNL_INCLUDE_INTERNAL_POWERPC_KE_H */
 
 /* EOF */
diff --git a/reactos/ntoskrnl/kd/kdmain.c b/reactos/ntoskrnl/kd/kdmain.c
index ab173d17f18..08be860ae2d 100644
--- a/reactos/ntoskrnl/kd/kdmain.c
+++ b/reactos/ntoskrnl/kd/kdmain.c
@@ -108,7 +108,9 @@ KdpEnterDebuggerException(IN PKTRAP_FRAME TrapFrame,
 {
     KD_CONTINUE_TYPE Return;
     ULONG ExceptionCommand = ExceptionRecord->ExceptionInformation[0];
+#ifdef _M_IX86
     ULONG EipOld;
+#endif
 
     /* Check if this was a breakpoint due to DbgPrint or Load/UnloadSymbols */
     if ((ExceptionRecord->ExceptionCode == STATUS_BREAKPOINT) &&
@@ -133,7 +135,9 @@ KdpEnterDebuggerException(IN PKTRAP_FRAME TrapFrame,
         }
 
         /* This we can handle: simply bump EIP */
+#ifdef _M_IX86
         Context->Eip++;
+#endif
         return TRUE;
     }
 
@@ -141,7 +145,9 @@ KdpEnterDebuggerException(IN PKTRAP_FRAME TrapFrame,
     if (KdDebuggerNotPresent) return FALSE;
 
     /* Save old EIP value */
+#ifdef _M_IX86
     EipOld = Context->Eip;
+#endif
 
     /* Call KDBG if available */
     Return = KdbEnterDebuggerException(ExceptionRecord,
@@ -159,7 +165,9 @@ KdpEnterDebuggerException(IN PKTRAP_FRAME TrapFrame,
 #else
         /* We simulate the original behaviour when KDBG is turned off.
            Return var is set to kdHandleException, thus we always return FALSE */
+#ifdef _M_IX86
         Context->Eip = EipOld;
+#endif
 #endif
     }
 
diff --git a/reactos/ntoskrnl/kd/wrappers/gdbstub_powerpc.c b/reactos/ntoskrnl/kd/wrappers/gdbstub_powerpc.c
new file mode 100644
index 00000000000..902f858de17
--- /dev/null
+++ b/reactos/ntoskrnl/kd/wrappers/gdbstub_powerpc.c
@@ -0,0 +1,1714 @@
+/****************************************************************************
+
+   THIS SOFTWARE IS NOT COPYRIGHTED
+
+   HP offers the following for use in the public domain.  HP makes no
+   warranty with regard to the software or it's performance and the
+   user accepts the software "AS IS" with all faults.
+
+   HP DISCLAIMS ANY WARRANTIES, EXPRESS OR IMPLIED, WITH REGARD
+   TO THIS SOFTWARE INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+   OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+
+****************************************************************************/
+
+/****************************************************************************
+ *  Header: remcom.c,v 1.34 91/03/09 12:29:49 glenne Exp $
+ *
+ *  Module name: remcom.c $
+ *  Revision: 1.34 $
+ *  Date: 91/03/09 12:29:49 $
+ *  Contributor:     Lake Stevens Instrument Division$
+ *
+ *  Description:     low level support for gdb debugger. $
+ *
+ *  Considerations:  only works on target hardware $
+ *
+ *  Written by:      Glenn Engel $
+ *  ModuleState:     Experimental $
+ *
+ *  NOTES:           See Below $
+ *
+ *  Modified for 386 by Jim Kingdon, Cygnus Support.
+ *  Modified for ReactOS by Casper S. Hornstrup <chorns@users.sourceforge.net>
+ *
+ *  To enable debugger support, two things need to happen.  One, setting
+ *  up a routine so that it is in the exception path, is necessary in order
+ *  to allow any breakpoints or error conditions to be properly intercepted
+ *  and reported to gdb.
+ *  Two, a breakpoint needs to be generated to begin communication.
+ *
+ *  Because gdb will sometimes write to the stack area to execute function
+ *  calls, this program cannot rely on using the supervisor stack so it
+ *  uses it's own stack area.
+ *
+ *************
+ *
+ *    The following gdb commands are supported:
+ *
+ * command          function                               Return value
+ *
+ *    g             return the value of the CPU Registers  hex data or ENN
+ *    G             set the value of the CPU Registers     OK or ENN
+ *
+ *    mAA..AA,LLLL  Read LLLL bytes at address AA..AA      hex data or ENN
+ *    MAA..AA,LLLL: Write LLLL bytes at address AA.AA      OK or ENN
+ *
+ *    c             Resume at current address              SNN   ( signal NN)
+ *    cAA..AA       Continue at address AA..AA             SNN
+ *
+ *    s             Step one instruction                   SNN
+ *    sAA..AA       Step one instruction from AA..AA       SNN
+ *
+ *    k             kill
+ *
+ *    ?             What was the last sigval ?             SNN   (signal NN)
+ *
+ * All commands and responses are sent with a packet which includes a
+ * Checksum.  A packet consists of
+ *
+ * $<packet info>#<Checksum>.
+ *
+ * where
+ * <packet info> :: <characters representing the command or response>
+ * <Checksum>    :: < two hex digits computed as modulo 256 sum of <packetinfo>>
+ *
+ * When a packet is received, it is first acknowledged with either '+' or '-'.
+ * '+' indicates a successful transfer.  '-' indicates a failed transfer.
+ *
+ * Example:
+ *
+ * Host:                  Reply:
+ * $m0,10#2a               +$00010203040506070809101112131415#42
+ *
+ ****************************************************************************/
+
+#include <ntoskrnl.h>
+#define NDEBUG
+#include <internal/debug.h>
+
+/************************************************************************/
+/* BUFMAX defines the maximum number of characters in inbound/outbound buffers*/
+/* at least NUMREGBYTES*2 are needed for register packets */
+#define BUFMAX 1000
+
+static BOOLEAN GspInitialized;
+
+static BOOLEAN GspRemoteDebug;
+
+static CONST CHAR HexChars[]="0123456789abcdef";
+
+static PETHREAD GspRunThread; /* NULL means run all threads */
+static PETHREAD GspDbgThread;
+static PETHREAD GspEnumThread;
+
+static FAST_MUTEX GspLock;
+
+extern LIST_ENTRY PsActiveProcessHead;
+KD_PORT_INFORMATION GdbPortInfo = { 2, 115200, 0 }; /* FIXME hardcoded for COM2, 115200 baud */
+
+/* Number of Registers.  */
+#define NUMREGS 16
+
+enum REGISTER_NAMES
+{
+  EAX, ECX, EDX, EBX, ESP, EBP, ESI, EDI,
+  PC /* also known as eip */,
+  PS /* also known as eflags */,
+  CS, SS, DS, ES, FS, GS
+};
+
+typedef struct _CPU_REGISTER
+{
+  ULONG Size;
+  ULONG OffsetInTF;
+  ULONG OffsetInContext;
+  BOOLEAN SetInContext;
+} CPU_REGISTER, *PCPU_REGISTER;
+
+static CPU_REGISTER GspRegisters[NUMREGS] =
+{
+};
+
+static PCHAR GspThreadStates[DeferredReady+1] =
+{
+  "Initialized",
+  "Ready",
+  "Running",
+  "Standby",
+  "Terminated",
+  "Waiting",
+  "Transition",
+  "DeferredReady"
+};
+
+
+LONG
+HexValue(CHAR ch)
+{
+  if ((ch >= '0') && (ch <= '9'))
+    {
+      return (ch - '0');
+    }
+  if ((ch >= 'a') && (ch <= 'f'))
+    {
+      return (ch - 'a' + 10);
+    }
+  if ((ch >= 'A') && (ch <= 'F'))
+    {
+      return (ch - 'A' + 10);
+    }
+
+  return -1;
+}
+
+static CHAR GspInBuffer[BUFMAX];
+static CHAR GspOutBuffer[BUFMAX];
+
+VOID
+GdbPutChar(UCHAR Value)
+{
+  KdPortPutByteEx(&GdbPortInfo, Value);
+}
+
+UCHAR
+GdbGetChar(VOID)
+{
+  UCHAR Value;
+
+  while (!KdPortGetByteEx(&GdbPortInfo, &Value))
+    ;
+
+  return Value;
+}
+
+/* scan for the sequence $<data>#<Checksum>     */
+
+PCHAR
+GspGetPacket()
+{
+  PCHAR Buffer = &GspInBuffer[0];
+  CHAR Checksum;
+  CHAR XmitChecksum;
+  ULONG Count;
+  CHAR ch;
+
+  while (TRUE)
+    {
+      /* wait around for the start character, ignore all other characters */
+      while ((ch = GdbGetChar ()) != '$')
+        ;
+
+    retry:
+      Checksum = 0;
+      XmitChecksum = -1;
+      Count = 0;
+
+      /* now, read until a # or end of Buffer is found */
+      while (Count < BUFMAX)
+        {
+          ch = GdbGetChar();
+          if (ch == '$')
+            {
+              goto retry;
+            }
+          if (ch == '#')
+            {
+              break;
+            }
+          Checksum = Checksum + ch;
+          Buffer[Count] = ch;
+          Count = Count + 1;
+        }
+      Buffer[Count] = 0;
+
+      if (ch == '#')
+        {
+          ch = GdbGetChar();
+          XmitChecksum = (CHAR)(HexValue(ch) << 4);
+          ch = GdbGetChar();
+          XmitChecksum += (CHAR)(HexValue(ch));
+
+          if (Checksum != XmitChecksum)
+            {
+              GdbPutChar('-'); /* failed checksum */
+            }
+          else
+            {
+              GdbPutChar('+'); /* successful transfer */
+
+              return &Buffer[0];
+            }
+        }
+    }
+}
+
+/* send the packet in Buffer.  */
+
+VOID
+GspPutPacket(PCHAR Buffer)
+{
+  CHAR Checksum;
+  LONG Count;
+  CHAR ch;
+
+  /*  $<packet info>#<Checksum>. */
+  do
+    {
+      GdbPutChar('$');
+      Checksum = 0;
+      Count = 0;
+
+      while ((ch = Buffer[Count]))
+        {
+          GdbPutChar(ch);
+          Checksum += ch;
+          Count += 1;
+        }
+
+      GdbPutChar('#');
+      GdbPutChar(HexChars[(Checksum >> 4) & 0xf]);
+      GdbPutChar(HexChars[Checksum & 0xf]);
+    }
+  while (GdbGetChar() != '+');
+}
+
+
+VOID
+GspPutPacketNoWait(PCHAR Buffer)
+{
+  CHAR Checksum;
+  LONG Count;
+  CHAR ch;
+
+  /*  $<packet info>#<Checksum>. */
+  GdbPutChar('$');
+  Checksum = 0;
+  Count = 0;
+
+  while ((ch = Buffer[Count]))
+    {
+      GdbPutChar(ch);
+      Checksum += ch;
+      Count += 1;
+    }
+
+  GdbPutChar('#');
+  GdbPutChar(HexChars[(Checksum >> 4) & 0xf]);
+  GdbPutChar(HexChars[Checksum & 0xf]);
+}
+
+/* Indicate to caller of GspMem2Hex or GspHex2Mem that there has been an
+   error.  */
+static volatile BOOLEAN GspMemoryError = FALSE;
+static volatile void *GspAccessLocation = NULL;
+
+static CHAR
+GspReadMemSafe(PCHAR Address)
+{
+  CHAR ch;
+
+  if (NULL == Address)
+    {
+      GspMemoryError = TRUE;
+      return '\0';
+    }
+
+  GspAccessLocation = Address;
+  ch = *Address;
+  GspAccessLocation = NULL;
+
+  return ch;
+}
+
+/* Convert the memory pointed to by Address into hex, placing result in Buffer */
+/* Return a pointer to the last char put in Buffer (null) */
+/* If MayFault is TRUE, then we should set GspMemoryError in response to
+   a fault; if FALSE treat a fault like any other fault in the stub.  */
+static PCHAR
+GspMem2Hex(PCHAR Address,
+  PCHAR Buffer,
+  LONG Count,
+  BOOLEAN MayFault)
+{
+  ULONG i;
+  CHAR ch;
+
+  for (i = 0; i < (ULONG) Count; i++)
+    {
+      if (MayFault)
+        {
+          ch = GspReadMemSafe(Address);
+          if (GspMemoryError)
+            {
+              return Buffer;
+            }
+        }
+      else
+        {
+          ch = *Address;
+        }
+      *Buffer++ = HexChars[(ch >> 4) & 0xf];
+      *Buffer++ = HexChars[ch & 0xf];
+      Address++;
+    }
+
+  *Buffer = 0;
+  return Buffer;
+}
+
+static ULONG
+GspWriteMem(PCHAR Address,
+  ULONG Count,
+  BOOLEAN MayFault,
+  CHAR (*GetContent)(PVOID Context, ULONG Offset),
+  PVOID Context)
+{
+  PCHAR Current;
+  PCHAR Page;
+  ULONG CountInPage;
+  ULONG i;
+  CHAR ch;
+  ULONG OldProt = 0;
+
+  Current = Address;
+  while (Current < Address + Count)
+    {
+      Page = (PCHAR)PAGE_ROUND_DOWN(Current);
+      if (Address + Count <= Page + PAGE_SIZE)
+        {
+          /* Fits in this page */
+          CountInPage = Count;
+        }
+      else
+        {
+          /* Flows into next page, handle only current page in this iteration */
+          CountInPage = PAGE_SIZE - (Address - Page);
+        }
+      if (MayFault)
+        {
+          OldProt = MmGetPageProtect(NULL, Address);
+          MmSetPageProtect(NULL, Address, PAGE_EXECUTE_READWRITE);
+        }
+
+      for (i = 0; i < CountInPage && ! GspMemoryError; i++)
+        {
+          ch = (*GetContent)(Context, Current - Address);
+
+          if (MayFault)
+            {
+              GspAccessLocation = Current;
+            }
+          *Current = ch;
+          if (MayFault)
+            {
+              GspAccessLocation = NULL;
+            }
+          Current++;
+        }
+      if (MayFault)
+        {
+          MmSetPageProtect(NULL, Page, OldProt);
+          if (GspMemoryError)
+            {
+              return Current - Address;
+            }
+        }
+    }
+
+  return Current - Address;
+}
+
+static CHAR
+GspHex2MemGetContent(PVOID Context, ULONG Offset)
+{
+  return (CHAR)((HexValue(*((PCHAR) Context + 2 * Offset)) << 4) +
+                HexValue(*((PCHAR) Context + 2 * Offset + 1)));
+}
+
+/* Convert the hex array pointed to by Buffer into binary to be placed at Address */
+/* Return a pointer to the character AFTER the last byte read from Buffer */
+static PCHAR
+GspHex2Mem(PCHAR Buffer,
+  PCHAR Address,
+  ULONG Count,
+  BOOLEAN MayFault)
+{
+  Count = GspWriteMem(Address, Count, MayFault, GspHex2MemGetContent, Buffer);
+
+  return Buffer + 2 * Count;
+}
+
+static CHAR
+GspWriteMemSafeGetContent(PVOID Context, ULONG Offset)
+{
+  ASSERT(0 == Offset);
+
+  return *((PCHAR) Context);
+}
+
+static void
+GspWriteMemSafe(PCHAR Address,
+  CHAR Ch)
+{
+  GspWriteMem(Address, 1, TRUE, GspWriteMemSafeGetContent, &Ch);
+}
+
+
+/* This function takes the 386 exception vector and attempts to
+   translate this number into a unix compatible signal value */
+ULONG
+GspComputeSignal(NTSTATUS ExceptionCode)
+{
+  ULONG SigVal;
+
+  switch (ExceptionCode)
+    {
+    case STATUS_INTEGER_DIVIDE_BY_ZERO:
+      SigVal = 8; /* divide by zero */
+      break;
+    case STATUS_SINGLE_STEP:
+    case STATUS_BREAKPOINT:
+      SigVal = 5; /* breakpoint */
+      break;
+    case STATUS_INTEGER_OVERFLOW:
+    case STATUS_ARRAY_BOUNDS_EXCEEDED:
+      SigVal = 16; /* bound instruction */
+      break;
+    case STATUS_ILLEGAL_INSTRUCTION:
+      SigVal = 4; /* Invalid opcode */
+      break;
+    case STATUS_STACK_OVERFLOW:
+    case STATUS_DATATYPE_MISALIGNMENT:
+    case STATUS_ACCESS_VIOLATION:
+      SigVal = 11; /* access violation */
+      break;
+    default:
+      SigVal = 7; /* "software generated" */
+    }
+  return SigVal;
+}
+
+
+/**********************************************/
+/* WHILE WE FIND NICE HEX CHARS, BUILD A LONG */
+/* RETURN NUMBER OF CHARS PROCESSED           */
+/**********************************************/
+LONG
+GspHex2Long(PCHAR *Address,
+  PLONG Value)
+{
+  LONG NumChars = 0;
+  LONG Hex;
+
+  *Value = 0;
+
+  while (**Address)
+    {
+      Hex = HexValue(**Address);
+      if (Hex >= 0)
+        {
+          *Value = (*Value << 4) | Hex;
+          NumChars++;
+        }
+      else
+        {
+          break;
+        }
+
+      (*Address)++;
+    }
+
+  return NumChars;
+}
+
+
+VOID
+GspLong2Hex(PCHAR *Address,
+  LONG Value)
+{
+  LONG Save;
+
+  Save = (((Value >> 0) & 0xff) << 24) |
+         (((Value >> 8) & 0xff) << 16) |
+         (((Value >> 16) & 0xff) << 8) |
+         (((Value >> 24) & 0xff) << 0);
+  *Address = GspMem2Hex((PCHAR) &Save, *Address, 4, FALSE);
+}
+
+
+/*
+ * When coming from kernel mode, Esp is not stored in the trap frame.
+ * Instead, it was pointing to the location of the TrapFrame Esp member
+ * when the exception occured. When coming from user mode, Esp is just
+ * stored in the TrapFrame Esp member.
+ */
+static LONG
+GspGetEspFromTrapFrame(PKTRAP_FRAME TrapFrame)
+{
+  return KeGetPreviousMode() == KernelMode
+         ? (LONG) &TrapFrame->Gpr1 : (LONG)TrapFrame->Gpr1;
+}
+
+
+static VOID
+GspGetRegisters(PCHAR Address,
+  PKTRAP_FRAME TrapFrame)
+{
+  ULONG_PTR Value;
+  PULONG p;
+  ULONG i;
+  PETHREAD Thread;
+  ULONG_PTR *KernelStack;
+
+  if (NULL == GspDbgThread)
+    {
+      Thread = PsGetCurrentThread();
+    }
+  else
+    {
+      TrapFrame = GspDbgThread->Tcb.TrapFrame;
+      Thread = GspDbgThread;
+    }
+
+  if (Waiting == Thread->Tcb.State)
+    {
+      KernelStack = Thread->Tcb.KernelStack;
+      for (i = 0; i < sizeof(GspRegisters) / sizeof(GspRegisters[0]); i++)
+        {
+          switch(i)
+            {
+            }
+          Address = GspMem2Hex((PCHAR) &Value, Address, GspRegisters[i].Size,
+                               FALSE);
+        }
+    }
+  else
+    {
+      for (i = 0; i < sizeof(GspRegisters) / sizeof(GspRegisters[0]); i++)
+        {
+          if (TrapFrame)
+            {
+              if (ESP == i)
+                {
+                  Value = GspGetEspFromTrapFrame(TrapFrame);
+                }
+              else
+                {
+                  p = (PULONG)((ULONG_PTR) TrapFrame +
+                               GspRegisters[i].OffsetInTF);
+                  Value = *p;
+                }
+            }
+          else if (i == PC)
+            {
+              /*
+               * This thread has not been sheduled yet so assume it
+               * is still in PsBeginThreadWithContextInternal().
+               */
+              Value = (ULONG)KiThreadStartup;
+            }
+          else
+            {
+              Value = 0;
+            }
+          Address = GspMem2Hex((PCHAR) &Value, Address,
+                               GspRegisters[i].Size, FALSE);
+        }
+    }
+}
+
+
+VOID
+GspSetRegistersInTrapFrame(PCHAR Address,
+  PCONTEXT Context,
+  PKTRAP_FRAME TrapFrame)
+{
+  ULONG Value;
+  PCHAR Buffer;
+  PULONG p;
+  ULONG i;
+
+  if (!TrapFrame)
+    {
+      return;
+    }
+
+  Buffer = Address;
+  for (i = 0; i < NUMREGS; i++)
+    {
+      if (GspRegisters[i].SetInContext)
+        {
+          p = (PULONG) ((ULONG_PTR) Context + GspRegisters[i].OffsetInContext);
+        }
+      else
+        {
+          p = (PULONG) ((ULONG_PTR) TrapFrame + GspRegisters[i].OffsetInTF);
+        }
+      Value = 0;
+      Buffer = GspHex2Mem(Buffer, (PCHAR) &Value, GspRegisters[i].Size, FALSE);
+      *p = Value;
+    }
+}
+
+
+VOID
+GspSetSingleRegisterInTrapFrame(PCHAR Address,
+  LONG Number,
+  PCONTEXT Context,
+  PKTRAP_FRAME TrapFrame)
+{
+  ULONG Value;
+  PULONG p;
+
+  if (!TrapFrame)
+    {
+      return;
+    }
+
+  if (GspRegisters[Number].SetInContext)
+    {
+      p = (PULONG) ((ULONG_PTR) Context + GspRegisters[Number].OffsetInContext);
+    }
+  else
+    {
+      p = (PULONG) ((ULONG_PTR) TrapFrame + GspRegisters[Number].OffsetInTF);
+    }
+  Value = 0;
+  GspHex2Mem(Address, (PCHAR) &Value, GspRegisters[Number].Size, FALSE);
+  *p = Value;
+}
+
+
+BOOLEAN
+GspFindThread(PCHAR Data,
+  PETHREAD *Thread)
+{
+  PETHREAD ThreadInfo = NULL;
+
+  if (strcmp (Data, "-1") == 0)
+    {
+      /* All threads */
+      ThreadInfo = NULL;
+    }
+  else
+    {
+      ULONG uThreadId;
+      HANDLE ThreadId;
+      PCHAR ptr = &Data[0];
+
+      GspHex2Long(&ptr, (PLONG) &uThreadId);
+      ThreadId = (HANDLE)uThreadId;
+
+      if (!NT_SUCCESS(PsLookupThreadByThreadId(ThreadId, &ThreadInfo)))
+        {
+          *Thread = NULL;
+          return FALSE;
+        }
+    }
+  *Thread = ThreadInfo;
+  return TRUE;
+}
+
+
+VOID
+GspSetThread(PCHAR Request)
+{
+  PETHREAD ThreadInfo;
+  PCHAR ptr = &Request[1];
+
+  switch (Request[0])
+  {
+    case 'c': /* Run thread */
+      if (GspFindThread(ptr, &ThreadInfo))
+        {
+          GspOutBuffer[0] = 'O';
+          GspOutBuffer[1] = 'K';
+
+          if (NULL != GspRunThread)
+            {
+              ObDereferenceObject(GspRunThread);
+            }
+          GspRunThread = ThreadInfo;
+          if (NULL != GspRunThread)
+            {
+              ObReferenceObject(GspRunThread);
+            }
+        }
+      else
+        {
+          GspOutBuffer[0] = 'E';
+        }
+      break;
+    case 'g': /* Debug thread */
+      if (GspFindThread(ptr, &ThreadInfo))
+        {
+          GspOutBuffer[0] = 'O';
+          GspOutBuffer[1] = 'K';
+
+          if (NULL != GspDbgThread)
+            {
+              ObDereferenceObject(GspDbgThread);
+            }
+
+          if (ThreadInfo == PsGetCurrentThread())
+            {
+              GspDbgThread = NULL;
+              ObDereferenceObject(ThreadInfo);
+            }
+          else
+            {
+              GspDbgThread = ThreadInfo;
+            }
+        }
+      else
+        {
+          GspOutBuffer[0] = 'E';
+        }
+      break;
+    default:
+      break;
+  }
+}
+
+
+VOID
+GspQuery(PCHAR Request)
+{
+  ULONG Value;
+
+  if (strncmp(Request, "C", 1) == 0)
+    {
+      PCHAR ptr = &GspOutBuffer[2];
+
+      /* Get current thread id */
+      GspOutBuffer[0] = 'Q';
+      GspOutBuffer[1] = 'C';
+      if (NULL != GspDbgThread)
+        {
+          Value = (ULONG) GspDbgThread->Cid.UniqueThread;
+        }
+      else
+        {
+          Value = (ULONG) PsGetCurrentThread()->Cid.UniqueThread;
+        }
+      GspLong2Hex(&ptr, Value);
+    }
+  else if (strncmp(Request, "fThreadInfo", 11) == 0)
+    {
+      PEPROCESS Process;
+      PLIST_ENTRY AThread, AProcess;
+      PCHAR ptr = &GspOutBuffer[1];
+
+      /* Get first thread id */
+      GspEnumThread = NULL;
+      AProcess = PsActiveProcessHead.Flink;
+      while(AProcess != &PsActiveProcessHead)
+        {
+          Process = CONTAINING_RECORD(AProcess, EPROCESS, ActiveProcessLinks);
+          AThread = Process->ThreadListHead.Flink;
+          if (AThread != &Process->ThreadListHead)
+            {
+              GspEnumThread = CONTAINING_RECORD(Process->ThreadListHead.Flink,
+                                                ETHREAD, ThreadListEntry);
+              break;
+            }
+          AProcess = AProcess->Flink;
+        }
+      if(GspEnumThread != NULL)
+        {
+          GspOutBuffer[0] = 'm';
+          Value = (ULONG) GspEnumThread->Cid.UniqueThread;
+          GspLong2Hex(&ptr, Value);
+        }
+      else
+        {
+          /* FIXME - what to do here? This case should never happen though, there
+                     should always be at least one thread on the system... */
+          /* GspOutBuffer[0] = 'l'; */
+        }
+    }
+  else if (strncmp(Request, "sThreadInfo", 11) == 0)
+    {
+      PEPROCESS Process;
+      PLIST_ENTRY AThread, AProcess;
+      PCHAR ptr = &GspOutBuffer[1];
+
+      /* Get next thread id */
+      if (GspEnumThread != NULL)
+        {
+          /* find the next thread */
+          Process = GspEnumThread->ThreadsProcess;
+          if(GspEnumThread->ThreadListEntry.Flink != &Process->ThreadListHead)
+            {
+              GspEnumThread = CONTAINING_RECORD(GspEnumThread->ThreadListEntry.Flink,
+                                                 ETHREAD, ThreadListEntry);
+            }
+          else
+            {
+              PETHREAD Thread = NULL;
+              AProcess = Process->ActiveProcessLinks.Flink;
+              while(AProcess != &PsActiveProcessHead)
+                {
+                  Process = CONTAINING_RECORD(AProcess, EPROCESS, ActiveProcessLinks);
+                  AThread = Process->ThreadListHead.Flink;
+                  if (AThread != &Process->ThreadListHead)
+                    {
+                      Thread = CONTAINING_RECORD(Process->ThreadListHead.Flink,
+                                                 ETHREAD, ThreadListEntry);
+                      break;
+                    }
+                  AProcess = AProcess->Flink;
+                }
+              GspEnumThread = Thread;
+            }
+
+          if (GspEnumThread != NULL)
+            {
+              /* return the ID */
+              GspOutBuffer[0] = 'm';
+              Value = (ULONG) GspEnumThread->Cid.UniqueThread;
+              GspLong2Hex(&ptr, Value);
+            }
+          else
+            {
+              GspOutBuffer[0] = 'l';
+            }
+        }
+      else
+        {
+          GspOutBuffer[0] = 'l';
+        }
+    }
+  else if (strncmp(Request, "ThreadExtraInfo", 15) == 0)
+    {
+      PETHREAD ThreadInfo;
+
+      /* Get thread information */
+      if (GspFindThread(Request + 16, &ThreadInfo))
+        {
+          char Buffer[64];
+          PEPROCESS Proc;
+
+          Proc = (PEPROCESS) ThreadInfo->ThreadsProcess;
+
+          Buffer[0] = '\0';
+          if (NULL != Proc )
+            {
+              sprintf(Buffer, "%s [%d:0x%x], ", Proc->ImageFileName,
+                      (int) Proc->UniqueProcessId,
+                      (int) ThreadInfo->Cid.UniqueThread);
+            }
+          strcpy(Buffer + strlen(Buffer),
+                 GspThreadStates[ThreadInfo->Tcb.State]);
+
+          ObDereferenceObject(ThreadInfo);
+
+          GspMem2Hex(Buffer, &GspOutBuffer[0], strlen(Buffer), FALSE);
+        }
+    }
+}
+
+VOID
+GspQueryThreadStatus(PCHAR Request)
+{
+  PETHREAD ThreadInfo;
+  PCHAR ptr = &Request[0];
+
+  if (GspFindThread(ptr, &ThreadInfo))
+    {
+      ObDereferenceObject(ThreadInfo);
+
+      GspOutBuffer[0] = 'O';
+      GspOutBuffer[1] = 'K';
+      GspOutBuffer[2] = '\0';
+    }
+  else
+    {
+      GspOutBuffer[0] = 'E';
+      GspOutBuffer[1] = '\0';
+    }
+}
+
+#define DR7_L0         0x00000001 /* Local breakpoint 0 enable */
+#define DR7_G0         0x00000002 /* Global breakpoint 0 enable */
+#define DR7_L1         0x00000004 /* Local breakpoint 1 enable */
+#define DR7_G1         0x00000008 /* Global breakpoint 1 enable */
+#define DR7_L2         0x00000010 /* Local breakpoint 2 enable */
+#define DR7_G2         0x00000020 /* Global breakpoint 2 enable */
+#define DR7_L3         0x00000040 /* Local breakpoint 3 enable */
+#define DR7_G3         0x00000080 /* Global breakpoint 3 enable */
+#define DR7_LE         0x00000100 /* Local exact breakpoint enable (old) */
+#define DR7_GE         0x00000200 /* Global exact breakpoint enable (old) */
+#define DR7_GD         0x00002000 /* General detect enable */
+#define DR7_TYPE0_MASK 0x00030000 /* Breakpoint 0 condition */
+#define DR7_LEN0_MASK  0x000c0000 /* Breakpoint 0 length */
+#define DR7_TYPE1_MASK 0x00300000 /* Breakpoint 1 condition */
+#define DR7_LEN1_MASK  0x00c00000 /* Breakpoint 1 length */
+#define DR7_TYPE2_MASK 0x03000000 /* Breakpoint 2 condition */
+#define DR7_LEN2_MASK  0x0c000000 /* Breakpoint 2 length */
+#define DR7_TYPE3_MASK 0x30000000 /* Breakpoint 3 condition */
+#define DR7_LEN3_MASK  0xc0000000 /* Breakpoint 3 length */
+#define DR7_GLOBAL_ENABLE(Bp) (2 << (2 * (Bp)))
+#define DR7_TYPE(Bp, Type)    ((Type) << (16 + 4 * (Bp)))
+#define DR7_LEN(Bp, Len)      ((Len) << (18 + 4 * (Bp)))
+
+#define I386_BP_TYPE_EXECUTE        0
+#define I386_BP_TYPE_DATA_WRITE     1
+#define I386_BP_TYPE_DATA_READWRITE 3
+
+#define I386_OPCODE_INT3 0xcc
+
+#define GDB_ZTYPE_MEMORY_BREAKPOINT   0
+#define GDB_ZTYPE_HARDWARE_BREAKPOINT 1
+#define GDB_ZTYPE_WRITE_WATCHPOINT    2
+#define GDB_ZTYPE_READ_WATCHPOINT     3
+#define GDB_ZTYPE_ACCESS_WATCHPOINT   4
+
+typedef struct _GSPHWBREAKPOINT
+{
+  ULONG Type;
+  ULONG_PTR Address;
+  ULONG Length;
+} GSPHWBREAKPOINT;
+
+#define MAX_HW_BREAKPOINTS 4
+static unsigned GspHwBreakpointCount = 0;
+static GSPHWBREAKPOINT GspHwBreakpoints[MAX_HW_BREAKPOINTS];
+
+typedef struct _GSPSWBREAKPOINT
+{
+  ULONG_PTR Address;
+  CHAR PrevContent;
+  BOOLEAN Active;
+} GSPSWBREAKPOINT;
+
+#define MAX_SW_BREAKPOINTS 64
+static unsigned GspSwBreakpointCount = 0;
+static GSPSWBREAKPOINT GspSwBreakpoints[MAX_SW_BREAKPOINTS];
+
+static void
+GspSetHwBreakpoint(ULONG Type, ULONG_PTR Address, ULONG Length)
+{
+  DPRINT("GspSetHwBreakpoint(%lu, 0x%p, %lu)\n", Type, Address, Length);
+
+  if (GDB_ZTYPE_READ_WATCHPOINT == Type)
+    {
+      DPRINT1("Read watchpoint not supported\n");
+      strcpy(GspOutBuffer, "E22");
+    }
+  else if (GDB_ZTYPE_HARDWARE_BREAKPOINT == Type && 1 != Length)
+    {
+      DPRINT1("Invalid length %lu for hardware breakpoint\n", Length);
+      strcpy(GspOutBuffer, "E22");
+    }
+  else if (1 != Length && 2 != Length && 4 != Length)
+    {
+      DPRINT1("Invalid length %lu for GDB Z type %lu\n", Length, Type);
+      strcpy(GspOutBuffer, "E22");
+    }
+  else if (0 != (Address & (Length - 1)))
+    {
+      DPRINT1("Invalid alignment for address 0x%p and length %d\n",
+              Address, Length);
+      strcpy(GspOutBuffer, "E22");
+    }
+  else if (MAX_HW_BREAKPOINTS == GspHwBreakpointCount)
+    {
+      DPRINT1("Trying to set too many hardware breakpoints\n");
+      strcpy(GspOutBuffer, "E22");
+    }
+  else
+    {
+      DPRINT("Stored at index %u\n", GspHwBreakpointCount);
+      GspHwBreakpoints[GspHwBreakpointCount].Type = Type;
+      GspHwBreakpoints[GspHwBreakpointCount].Address = Address;
+      GspHwBreakpoints[GspHwBreakpointCount].Length = Length;
+      GspHwBreakpointCount++;
+      strcpy(GspOutBuffer, "OK");
+    }
+}
+
+static void
+GspRemoveHwBreakpoint(ULONG Type, ULONG_PTR Address, ULONG Length)
+{
+  unsigned Index;
+
+  DPRINT("GspRemoveHwBreakpoint(%lu, 0x%p, %lu)\n", Type, Address, Length);
+  for (Index = 0; Index < GspHwBreakpointCount; Index++)
+    {
+      if (GspHwBreakpoints[Index].Type == Type &&
+          GspHwBreakpoints[Index].Address == Address &&
+          GspHwBreakpoints[Index].Length == Length)
+        {
+          DPRINT("Found match at index %u\n", Index);
+          if (Index + 1 < GspHwBreakpointCount)
+            {
+              memmove(GspHwBreakpoints + Index,
+                      GspHwBreakpoints + (Index + 1),
+                      (GspHwBreakpointCount - Index - 1) *
+                      sizeof(GSPHWBREAKPOINT));
+            }
+          GspHwBreakpointCount--;
+          strcpy(GspOutBuffer, "OK");
+          return;
+        }
+    }
+
+  DPRINT1("Not found\n");
+  strcpy(GspOutBuffer, "E22");
+}
+
+static void
+GspSetSwBreakpoint(ULONG_PTR Address)
+{
+  DPRINT("GspSetSwBreakpoint(0x%p)\n", Address);
+
+  if (MAX_SW_BREAKPOINTS == GspSwBreakpointCount)
+    {
+      DPRINT1("Trying to set too many software breakpoints\n");
+      strcpy(GspOutBuffer, "E22");
+    }
+  else
+    {
+      DPRINT("Stored at index %u\n", GspSwBreakpointCount);
+      GspSwBreakpoints[GspSwBreakpointCount].Address = Address;
+      GspSwBreakpoints[GspSwBreakpointCount].Active = FALSE;
+      GspSwBreakpointCount++;
+      strcpy(GspOutBuffer, "OK");
+    }
+}
+
+static void
+GspRemoveSwBreakpoint(ULONG_PTR Address)
+{
+  unsigned Index;
+
+  DPRINT("GspRemoveSwBreakpoint(0x%p)\n", Address);
+  for (Index = 0; Index < GspSwBreakpointCount; Index++)
+    {
+      if (GspSwBreakpoints[Index].Address == Address)
+        {
+          DPRINT("Found match at index %u\n", Index);
+          ASSERT(! GspSwBreakpoints[Index].Active);
+          if (Index + 1 < GspSwBreakpointCount)
+            {
+              memmove(GspSwBreakpoints + Index,
+                      GspSwBreakpoints + (Index + 1),
+                      (GspSwBreakpointCount - Index - 1) *
+                      sizeof(GSPSWBREAKPOINT));
+            }
+          GspSwBreakpointCount--;
+          strcpy(GspOutBuffer, "OK");
+          return;
+        }
+    }
+
+  DPRINT1("Not found\n");
+  strcpy(GspOutBuffer, "E22");
+}
+
+static void
+GspLoadHwBreakpoint(PKTRAP_FRAME TrapFrame,
+                    unsigned BpIndex,
+                    ULONG_PTR Address,
+                    ULONG Length,
+                    ULONG Type)
+{
+  DPRINT("GspLoadHwBreakpoint(0x%p, %d, 0x%p, %d)\n", TrapFrame, BpIndex,
+         Address, Type);
+
+  /* Set the DR7_Gx bit to globally enable the breakpoint */
+  TrapFrame->Dr7 |= DR7_GLOBAL_ENABLE(BpIndex) |
+                    DR7_LEN(BpIndex, Length) |
+                    DR7_TYPE(BpIndex, Type);
+
+  switch (BpIndex)
+    {
+    case 0:
+      DPRINT("Setting DR0 to 0x%p\n", Address);
+      TrapFrame->Dr0 = Address;
+      break;
+
+    case 1:
+      DPRINT("Setting DR1 to 0x%p\n", Address);
+      TrapFrame->Dr1 = Address;
+      break;
+
+    case 2:
+      DPRINT("Setting DR2 to 0x%p\n", Address);
+      TrapFrame->Dr2 = Address;
+      break;
+
+    case 3:
+      DPRINT("Setting DR3 to 0x%p\n", Address);
+      TrapFrame->Dr3 = Address;
+      break;
+    }
+}
+
+static void
+GspLoadBreakpoints(PKTRAP_FRAME TrapFrame)
+{
+  unsigned Index;
+  ULONG i386Type;
+
+  DPRINT("GspLoadBreakpoints\n");
+  DPRINT("DR7 on entry: 0x%08x\n", TrapFrame->Dr7);
+  /* Remove all breakpoints */
+  TrapFrame->Dr7 &= ~(DR7_L0 | DR7_L1 | DR7_L2 | DR7_L3 |
+                      DR7_G0 | DR7_G1 | DR7_G2 | DR7_G3 |
+                      DR7_TYPE0_MASK | DR7_LEN0_MASK |
+                      DR7_TYPE1_MASK | DR7_LEN1_MASK |
+                      DR7_TYPE2_MASK | DR7_LEN2_MASK |
+                      DR7_TYPE3_MASK | DR7_LEN3_MASK);
+
+  for (Index = 0; Index < GspHwBreakpointCount; Index++)
+    {
+      switch(GspHwBreakpoints[Index].Type)
+        {
+        case GDB_ZTYPE_HARDWARE_BREAKPOINT:
+          i386Type = I386_BP_TYPE_EXECUTE;
+          break;
+        case GDB_ZTYPE_WRITE_WATCHPOINT:
+          i386Type = I386_BP_TYPE_DATA_WRITE;
+          break;
+        case GDB_ZTYPE_ACCESS_WATCHPOINT:
+          i386Type = I386_BP_TYPE_DATA_READWRITE;
+          break;
+        default:
+          ASSERT(FALSE);
+          i386Type = I386_BP_TYPE_EXECUTE;
+          break;
+        }
+
+      GspLoadHwBreakpoint(TrapFrame, Index, GspHwBreakpoints[Index].Address,
+                          GspHwBreakpoints[Index].Length - 1, i386Type);
+    }
+
+  for (Index = 0; Index < GspSwBreakpointCount; Index++)
+    {
+      if (GspHwBreakpointCount + Index < MAX_HW_BREAKPOINTS)
+        {
+          DPRINT("Implementing software interrupt using hardware register\n");
+          GspLoadHwBreakpoint(TrapFrame, GspHwBreakpointCount + Index,
+                              GspSwBreakpoints[Index].Address, 0,
+                              I386_BP_TYPE_EXECUTE);
+          GspSwBreakpoints[Index].Active = FALSE;
+        }
+      else
+        {
+          DPRINT("Using real software breakpoint\n");
+          GspMemoryError = FALSE;
+          GspSwBreakpoints[Index].PrevContent = GspReadMemSafe((PCHAR) GspSwBreakpoints[Index].Address);
+          if (! GspMemoryError)
+            {
+              GspWriteMemSafe((PCHAR) GspSwBreakpoints[Index].Address, I386_OPCODE_INT3);
+            }
+          GspSwBreakpoints[Index].Active = ! GspMemoryError;
+          if (GspMemoryError)
+            {
+              DPRINT1("Failed to set software breakpoint at 0x%p\n",
+                      GspSwBreakpoints[Index].Address);
+            }
+          else
+            {
+              DPRINT("Successfully set software breakpoint at 0x%p\n",
+                     GspSwBreakpoints[Index].Address);
+    DPRINT1("Successfully set software breakpoint at 0x%p\n", GspSwBreakpoints[Index].Address);
+            }
+        }
+    }
+
+  DPRINT("Final DR7 value 0x%08x\n", TrapFrame->Dr7);
+}
+
+static void
+GspUnloadBreakpoints(PKTRAP_FRAME TrapFrame)
+{
+  unsigned Index;
+
+  DPRINT("GspUnloadHwBreakpoints\n");
+
+  for (Index = 0; Index < GspSwBreakpointCount; Index++)
+    {
+      if (GspSwBreakpoints[Index].Active)
+        {
+          GspMemoryError = FALSE;
+          GspWriteMemSafe((PCHAR) GspSwBreakpoints[Index].Address,
+                          GspSwBreakpoints[Index].PrevContent);
+          GspSwBreakpoints[Index].Active = FALSE;
+          if (GspMemoryError)
+            {
+              DPRINT1("Failed to remove software breakpoint from 0x%p\n",
+                      GspSwBreakpoints[Index].Address);
+            }
+          else
+            {
+              DPRINT("Successfully removed software breakpoint from 0x%p\n",
+                     GspSwBreakpoints[Index].Address);
+            }
+        }
+    }
+}
+
+static BOOLEAN gdb_attached_yet = FALSE;
+/*
+ * This function does all command procesing for interfacing to gdb.
+ */
+KD_CONTINUE_TYPE
+STDCALL
+KdpGdbEnterDebuggerException(PEXCEPTION_RECORD ExceptionRecord,
+                             PCONTEXT Context,
+                             PKTRAP_FRAME TrapFrame)
+{
+  BOOLEAN Stepping;
+  LONG Address;
+  LONG Length;
+  LONG SigVal = 0;
+  //LONG NewPC;
+  PCHAR ptr;
+
+  /* FIXME: Stop on other CPUs too */
+
+  if (STATUS_ACCESS_VIOLATION == (NTSTATUS) ExceptionRecord->ExceptionCode &&
+      NULL != GspAccessLocation &&
+      (ULONG_PTR) GspAccessLocation ==
+      (ULONG_PTR) ExceptionRecord->ExceptionInformation[1])
+    {
+      GspAccessLocation = NULL;
+      GspMemoryError = TRUE;
+      //Context->Eip += 3;
+    }
+  else
+    {
+      DPRINT("Thread %p entering stub\n", PsGetCurrentThread());
+      /* Can only debug 1 thread at a time... */
+      ExAcquireFastMutex(&GspLock);
+      DPRINT("Thread %p acquired mutex\n", PsGetCurrentThread());
+
+      /* Disable hardware debugging while we are inside the stub */
+      //Ke386SetDr7(0);
+      GspUnloadBreakpoints(TrapFrame);
+
+      /* Make sure we're debugging the current thread. */
+      if (NULL != GspDbgThread)
+        {
+          DPRINT1("Internal error: entering stub with non-NULL GspDbgThread\n");
+          ObDereferenceObject(GspDbgThread);
+          GspDbgThread = NULL;
+        }
+
+      /* ugly hack to avoid attempting to send status at the very
+       * beginning, right when GDB is trying to query the stub */
+      if (gdb_attached_yet)
+        {
+          LONG Esp;
+  
+          stop_reply:
+          /* reply to host that an exception has occurred */
+          SigVal = GspComputeSignal(ExceptionRecord->ExceptionCode);
+
+          ptr = GspOutBuffer;
+
+          *ptr++ = 'T'; /* notify gdb with signo, PC, FP and SP */
+          *ptr++ = HexChars[(SigVal >> 4) & 0xf];
+          *ptr++ = HexChars[SigVal & 0xf];
+
+          *ptr++ = HexChars[ESP];
+          *ptr++ = ':';
+  
+          Esp = GspGetEspFromTrapFrame(TrapFrame);      /* SP */
+          ptr = GspMem2Hex((PCHAR) &Esp, ptr, 4, 0);
+          *ptr++ = ';';
+  
+          *ptr++ = HexChars[EBP];
+          *ptr++ = ':';
+          //ptr = GspMem2Hex((PCHAR) &TrapFrame->Ebp, ptr, 4, 0);       /* FP */
+          *ptr++ = ';';
+  
+          *ptr++ = HexChars[PC];
+          *ptr++ = ':';
+          //ptr = GspMem2Hex((PCHAR) &TrapFrame->Eip, ptr, 4, 0);        /* PC */
+          *ptr++ = ';';
+
+          *ptr = '\0';
+
+          GspPutPacket(&GspOutBuffer[0]);
+        }
+      else
+        {
+          gdb_attached_yet = 1;
+        }
+      
+      Stepping = FALSE;
+
+      while (TRUE)
+        {
+          /* Zero the buffer now so we don't have to worry about the terminating zero character */
+          memset(GspOutBuffer, 0, sizeof(GspInBuffer));
+          ptr = GspGetPacket();
+
+          switch(*ptr++)
+            {
+            case '?':
+              /* a little hack to send more complete status information */
+              goto stop_reply;
+              GspOutBuffer[0] = 'S';
+              GspOutBuffer[1] = HexChars[SigVal >> 4];
+              GspOutBuffer[2] = HexChars[SigVal % 16];
+              GspOutBuffer[3] = 0;
+              break;
+            case 'd':
+              GspRemoteDebug = !GspRemoteDebug; /* toggle debug flag */
+              break;
+            case 'g': /* return the value of the CPU Registers */
+              GspGetRegisters(GspOutBuffer, TrapFrame);
+              break;
+            case 'G': /* set the value of the CPU Registers - return OK */
+              if (NULL != GspDbgThread)
+                {
+                  GspSetRegistersInTrapFrame(ptr, Context, GspDbgThread->Tcb.TrapFrame);
+                }
+              else
+                {
+                  GspSetRegistersInTrapFrame(ptr, Context, TrapFrame);
+                }
+              strcpy(GspOutBuffer, "OK");
+              break;
+            case 'P': /* set the value of a single CPU register - return OK */
+              {
+                LONG Register;
+
+                if ((GspHex2Long(&ptr, &Register)) && (*ptr++ == '='))
+                  {
+                    if ((Register >= 0) && (Register < NUMREGS))
+                      {
+                        if (GspDbgThread)
+                          {
+                            GspSetSingleRegisterInTrapFrame(ptr, Register,
+                                                            Context,
+                                                            GspDbgThread->Tcb.TrapFrame);
+                          }
+                        else
+                          {
+                            GspSetSingleRegisterInTrapFrame(ptr, Register,
+                                                            Context, TrapFrame);
+                          }
+                        strcpy(GspOutBuffer, "OK");
+                        break;
+                      }
+                  }
+
+                strcpy(GspOutBuffer, "E01");
+                break;
+              }
+
+            /* mAA..AA,LLLL  Read LLLL bytes at address AA..AA */
+            case 'm':
+              /* TRY TO READ %x,%x.  IF SUCCEED, SET PTR = 0 */
+              if (GspHex2Long(&ptr, &Address) &&
+                  *(ptr++) == ',' &&
+                  GspHex2Long(&ptr, &Length))
+                {
+                  PEPROCESS DbgProcess = NULL;
+
+                  ptr = NULL;
+                  if (NULL != GspDbgThread &&
+                      PsGetCurrentProcess() != GspDbgThread->ThreadsProcess)
+                    {
+                      DbgProcess = GspDbgThread->ThreadsProcess;
+                      KeAttachProcess(&DbgProcess->Pcb);
+                    }
+                  GspMemoryError = FALSE;
+                  GspMem2Hex((PCHAR) Address, GspOutBuffer, Length, 1);
+                  if (NULL != DbgProcess)
+                    {
+                      KeDetachProcess();
+                    }
+                  if (GspMemoryError)
+                    {
+                      strcpy(GspOutBuffer, "E03");
+                      DPRINT("Fault during memory read\n");
+                    }
+                }
+
+              if (NULL != ptr)
+                {
+                  strcpy(GspOutBuffer, "E01");
+                }
+              break;
+
+            /* MAA..AA,LLLL: Write LLLL bytes at address AA.AA return OK */
+            case 'M':
+              /* TRY TO READ '%x,%x:'.  IF SUCCEED, SET PTR = 0 */
+              if (GspHex2Long(&ptr, &Address))
+                {
+                  if (*(ptr++) == ',' &&
+                      GspHex2Long(&ptr, &Length) &&
+                      *(ptr++) == ':')
+                    {
+                      PEPROCESS DbgProcess = NULL;
+
+                      if (NULL != GspDbgThread &&
+                          PsGetCurrentProcess() != GspDbgThread->ThreadsProcess)
+                        {
+                          DbgProcess = GspDbgThread->ThreadsProcess;
+                          KeAttachProcess(&DbgProcess->Pcb);
+                        }
+                      GspMemoryError = FALSE;
+                      GspHex2Mem(ptr, (PCHAR) Address, Length, TRUE);
+                      if (NULL != DbgProcess)
+                        {
+                          KeDetachProcess();
+                        }
+                      if (GspMemoryError)
+                        {
+                          strcpy(GspOutBuffer, "E03");
+                          DPRINT("Fault during memory write\n");
+                        }
+                      else
+                        {
+                          strcpy(GspOutBuffer, "OK");
+                        }
+                      ptr = NULL;
+                    }
+                }
+
+              if (NULL != ptr)
+                {
+                  strcpy(GspOutBuffer, "E02");
+                }
+              break;
+
+            /* cAA..AA   Continue at address AA..AA(optional) */
+            /* sAA..AA   Step one instruction from AA..AA(optional) */
+            case 's':
+              Stepping = TRUE;
+            case 'c':
+              {
+                ULONG BreakpointNumber;
+                ULONG dr6_ = 0;
+
+                /* try to read optional parameter, pc unchanged if no parm */
+                if (GspHex2Long (&ptr, &Address))
+                  {
+                      //Context->Eip = Address;
+                  }
+
+                //NewPC = Context->Eip;
+
+                /* clear the trace bit */
+                //Context->EFlags &= 0xfffffeff;
+
+                /* set the trace bit if we're Stepping */
+                if (Stepping)
+                  {
+                      //Context->EFlags |= 0x100;
+                  }
+
+                // XXX arty load dr6
+                if (!(dr6_ & 0x4000))
+                  {
+                    for (BreakpointNumber = 0; BreakpointNumber < 4; ++BreakpointNumber)
+                      {
+                        if (dr6_ & (1 << BreakpointNumber))
+                          {
+                            if (GspHwBreakpoints[BreakpointNumber].Type == 0)
+                              {
+                                /* Set restore flag */
+                                  //Context->EFlags |= 0x10000;
+                                break;
+                              }
+                          }
+                      }
+                  }
+                GspLoadBreakpoints(TrapFrame);
+                // XXX load dr6
+                if (NULL != GspDbgThread)
+                  {
+                    ObDereferenceObject(GspDbgThread);
+                    GspDbgThread = NULL;
+                  }
+
+                DPRINT("Thread %p releasing mutex\n", PsGetCurrentThread());
+                ExReleaseFastMutex(&GspLock);
+                DPRINT("Thread %p leaving stub\n", PsGetCurrentThread());
+                return kdContinue;
+                break;
+              }
+
+            case 'k':  /* kill the program */
+              strcpy(GspOutBuffer, "OK");
+              break;
+              /* kill the program */
+
+            case 'H': /* Set thread */
+              GspSetThread(ptr);
+              break;
+
+            case 'q': /* Query */
+              GspQuery(ptr);
+              break;
+
+            case 'T': /* Query thread status */
+              GspQueryThreadStatus(ptr);
+              break;
+
+            case 'Z':
+              {
+                LONG Type;
+                LONG Address;
+                LONG Length;
+
+                GspHex2Long(&ptr, &Type);
+                ptr++;
+                GspHex2Long(&ptr, &Address);
+                ptr++;
+                GspHex2Long(&ptr, &Length);
+                if (0 == Type)
+                  {
+                  GspSetSwBreakpoint((ULONG_PTR) Address);
+                  }
+                else
+                  {
+                  GspSetHwBreakpoint(Type, (ULONG_PTR) Address, Length);
+                  }
+                break;
+              }
+
+            case 'z':
+              {
+                LONG Type;
+                LONG Address;
+                LONG Length;
+
+                GspHex2Long(&ptr, &Type);
+                ptr++;
+                GspHex2Long(&ptr, &Address);
+                ptr++;
+                GspHex2Long(&ptr, &Length);
+                if (0 == Type)
+                  {
+                  GspRemoveSwBreakpoint((ULONG_PTR) Address);
+                  }
+                else
+                  {
+                  GspRemoveHwBreakpoint(Type, (ULONG_PTR) Address, Length);
+                  }
+                break;
+              }
+
+            default:
+              break;
+            }
+
+          /* reply to the request */
+          GspPutPacket(GspOutBuffer);
+        }
+
+      /* not reached */
+      ASSERT(0);
+    }
+
+  if (NULL != GspDbgThread)
+    {
+      ObDereferenceObject(GspDbgThread);
+      GspDbgThread = NULL;
+    }
+
+  return kdContinue;
+}
+
+
+BOOLEAN
+STDCALL
+GspBreakIn(PKINTERRUPT Interrupt,
+  PVOID ServiceContext)
+{
+  PKTRAP_FRAME TrapFrame;
+  BOOLEAN DoBreakIn;
+  CONTEXT Context;
+  KIRQL OldIrql;
+  UCHAR Value;
+
+  DPRINT("Break In\n");
+
+  DoBreakIn = FALSE;
+  while (KdPortGetByteEx(&GdbPortInfo, &Value))
+    {
+      if (Value == 0x03)
+        {
+          DoBreakIn = TRUE;
+        }
+    }
+
+  if (!DoBreakIn)
+    {
+      return TRUE;
+    }
+
+  KeRaiseIrql(HIGH_LEVEL, &OldIrql);
+
+  TrapFrame = PsGetCurrentThread()->Tcb.TrapFrame;
+
+  KeTrapFrameToContext(TrapFrame, NULL, &Context);
+
+  KdpGdbEnterDebuggerException(NULL, &Context, TrapFrame);
+
+  KeContextToTrapFrame(&Context, NULL, TrapFrame, Context.ContextFlags, KernelMode);
+
+  KeLowerIrql(OldIrql);
+
+  return TRUE;
+}
+
+VOID
+STDCALL
+KdpGdbDebugPrint(PCH Message, ULONG Length)
+{
+}
+
+/* Initialize the GDB stub */
+VOID
+STDCALL
+KdpGdbStubInit(PKD_DISPATCH_TABLE WrapperTable,
+               ULONG BootPhase)
+{
+  if (!KdDebuggerEnabled || !KdpDebugMode.Gdb)
+    {
+      return;
+    }
+
+  if (BootPhase == 0)
+    {
+      ExInitializeFastMutex(&GspLock);
+
+      /* Write out the functions that we support for now */
+      WrapperTable->KdpInitRoutine = KdpGdbStubInit;
+      WrapperTable->KdpPrintRoutine = KdpGdbDebugPrint;
+      WrapperTable->KdpExceptionRoutine = KdpGdbEnterDebuggerException;
+
+      /* Initialize the Port */
+      KdPortInitializeEx(&GdbPortInfo, 0, 0);
+
+      KdpPort = GdbPortInfo.ComPort;
+    }
+  else if (BootPhase == 1)
+    {
+      GspInitialized = TRUE;
+
+      GspRunThread = NULL;
+      GspDbgThread = NULL;
+      GspEnumThread = NULL;
+
+      HalDisplayString("Waiting for GDB to attach\n");
+      DbgBreakPointWithStatus(DBG_STATUS_CONTROL_C);
+    }
+  else if (BootPhase == 2)
+    {
+      HalDisplayString("\n   GDB debugging enabled\n\n");
+    }
+}
+
+/* EOF */
diff --git a/reactos/ntoskrnl/ke/bug.c b/reactos/ntoskrnl/ke/bug.c
index f88741f2363..03654bc85ce 100644
--- a/reactos/ntoskrnl/ke/bug.c
+++ b/reactos/ntoskrnl/ke/bug.c
@@ -311,12 +311,12 @@ VOID
 NTAPI
 KeRosDumpTriageForBugZillaReport(VOID)
 {
+#if 0
     extern BOOLEAN KiFastSystemCallDisable, KiSMTProcessorsPresent;
     extern ULONG KeI386MachineType, MxcsrFeatureMask;
     extern BOOLEAN Ke386Pae, Ke386NoExecute;
 
     DbgPrint("ReactOS has crashed! Please go to http://www.reactos.org/bugzilla/enter_bug.cgi to file a bug!\n");
-#ifdef __i386__
     DbgPrint("\nHardware Information\n");
     DbgPrint("Processor Architecture: %d\n"
              "Feature Bits: %d\n"
@@ -539,7 +539,7 @@ NTAPI
 KiBugCheckDebugBreak(IN ULONG StatusCode)
 {
     /* If KDBG isn't connected, freeze the CPU, otherwise, break */
-    if (KdDebuggerNotPresent) for (;;) Ke386HaltProcessor();
+    if (KdDebuggerNotPresent) for (;;) KeArchHaltProcessor();
     DbgBreakPointWithStatus(StatusCode);
 }
 
@@ -867,8 +867,12 @@ KeBugCheckWithTf(IN ULONG BugCheckCode,
             if ((TrapFrame) &&
                 (BugCheckCode != KERNEL_MODE_EXCEPTION_NOT_HANDLED))
             {
+#ifdef _M_IX86
                 /* Get EIP */
                 Eip = (PVOID)TrapFrame->Eip;
+#elif defined(_M_PPC)
+                Eip = (PVOID)TrapFrame->Dr0; /* srr0 */
+#endif
             }
             break;
 
@@ -963,9 +967,14 @@ KeBugCheckWithTf(IN ULONG BugCheckCode,
             /* Check if we have a frame now */
             if (TrapFrame)
             {
+#ifdef _M_IX86
                 /* Get EIP */
                 Eip = (PVOID)TrapFrame->Eip;
                 KiBugCheckData[3] = (ULONG)Eip;
+#elif defined(_M_PPC)
+                Eip = (PVOID)TrapFrame->Dr0; /* srr0 */
+                KiBugCheckData[3] = (ULONG)Eip;
+#endif
 
                 /* Find out if was in the kernel or drivers */
                 DriverBase = KiPcToFileHeader(Eip,
@@ -1164,7 +1173,7 @@ KeBugCheckWithTf(IN ULONG BugCheckCode,
         else if (KeBugCheckOwnerRecursionCount > 2)
         {
             /* Halt the CPU */
-            for (;;) Ke386HaltProcessor();
+            for (;;) KeArchHaltProcessor();
         }
     }
 
diff --git a/reactos/ntoskrnl/ke/powerpc/cpu.c b/reactos/ntoskrnl/ke/powerpc/cpu.c
new file mode 100644
index 00000000000..71185a50435
--- /dev/null
+++ b/reactos/ntoskrnl/ke/powerpc/cpu.c
@@ -0,0 +1,277 @@
+/*
+ * PROJECT:         ReactOS Kernel
+ * LICENSE:         GPL - See COPYING in the top level directory
+ * FILE:            ntoskrnl/ke/i386/cpu.c
+ * PURPOSE:         Routines for CPU-level support
+ * PROGRAMMERS:     Alex Ionescu (alex.ionescu@reactos.org)
+ */
+
+/* INCLUDES *****************************************************************/
+
+#include <ntoskrnl.h>
+#define NDEBUG
+#include <debug.h>
+
+/* GLOBALS *******************************************************************/
+
+/* CPU Features and Flags */
+ULONG KeProcessorArchitecture;
+ULONG KeProcessorLevel;
+ULONG KeProcessorRevision;
+ULONG KeFeatureBits;
+ULONG KeLargestCacheLine = 0x40;
+ULONG KeDcacheFlushCount = 0;
+ULONG KeIcacheFlushCount = 0;
+ULONG KiDmaIoCoherency = 0;
+CHAR KeNumberProcessors;
+KAFFINITY KeActiveProcessors = 1;
+BOOLEAN KiSMTProcessorsPresent;
+
+/* CPU Signatures */
+#if 0
+CHAR CmpIntelID[]       = "GenuineIntel";
+CHAR CmpAmdID[]         = "AuthenticAMD";
+CHAR CmpCyrixID[]       = "CyrixInstead";
+CHAR CmpTransmetaID[]   = "GenuineTMx86";
+CHAR CmpCentaurID[]     = "CentaurHauls";
+CHAR CmpRiseID[]        = "RiseRiseRise";
+#endif
+
+/* SUPPORT ROUTINES FOR MSVC COMPATIBILITY ***********************************/
+
+VOID
+NTAPI
+CPUID(IN ULONG CpuInfo[4],
+      IN ULONG InfoType)
+{
+    RtlZeroMemory(CpuInfo, sizeof(CpuInfo));
+}
+
+VOID
+WRMSR(IN ULONG Register,
+      IN LONGLONG Value)
+{
+}
+
+LONGLONG
+RDMSR(IN ULONG Register)
+{
+    LARGE_INTEGER LargeVal;
+    LargeVal.QuadPart = 0;
+    return LargeVal.QuadPart;
+}
+
+/* FUNCTIONS *****************************************************************/
+
+VOID
+NTAPI
+KiSetProcessorType(VOID)
+{
+}
+
+ULONG
+NTAPI
+KiGetCpuVendor(VOID)
+{
+    return 0;
+}
+
+ULONG
+NTAPI
+KiGetFeatureBits(VOID)
+{
+    ULONG FeatureBits = 0;
+    /* Return the Feature Bits */
+    return FeatureBits;
+}
+
+VOID
+NTAPI
+KiGetCacheInformation(VOID)
+{
+}
+
+VOID
+NTAPI
+KiSetCR0Bits(VOID)
+{
+}
+
+VOID
+NTAPI
+KiInitializeTSS2(IN PKTSS Tss,
+                 IN PKGDTENTRY TssEntry OPTIONAL)
+{
+}
+
+VOID
+NTAPI
+KiInitializeTSS(IN PKTSS Tss)
+{
+}
+
+VOID
+FASTCALL
+Ki386InitializeTss(IN PKTSS Tss,
+                   IN PKIDTENTRY Idt,
+                   IN PKGDTENTRY Gdt)
+{
+}
+
+VOID
+NTAPI
+KeFlushCurrentTb(VOID)
+{
+}
+
+VOID
+NTAPI
+KiSaveProcessorControlState(OUT PKPROCESSOR_STATE ProcessorState)
+{
+}
+
+VOID
+NTAPI
+KiInitializeMachineType(VOID)
+{
+}
+
+ULONG_PTR
+NTAPI
+KiLoadFastSyscallMachineSpecificRegisters(IN ULONG_PTR Context)
+{
+    return 0;
+}
+
+VOID
+NTAPI
+KiRestoreFastSyscallReturnState(VOID)
+{
+}
+
+ULONG_PTR
+NTAPI
+Ki386EnableDE(IN ULONG_PTR Context)
+{
+    return 0;
+}
+
+ULONG_PTR
+NTAPI
+Ki386EnableFxsr(IN ULONG_PTR Context)
+{
+    return 0;
+}
+
+ULONG_PTR
+NTAPI
+Ki386EnableXMMIExceptions(IN ULONG_PTR Context)
+{
+    /* FIXME: Support this */
+    DPRINT1("Your machine supports XMMI exceptions but ReactOS doesn't\n");
+    return 0;
+}
+
+VOID
+NTAPI
+KiI386PentiumLockErrataFixup(VOID)
+{
+    /* FIXME: Support this */
+    DPRINT1("WARNING: Your machine has a CPU bug that ReactOS can't bypass!\n");
+}
+
+/* PUBLIC FUNCTIONS **********************************************************/
+
+/*
+ * @implemented
+ */
+NTSTATUS
+NTAPI
+KeSaveFloatingPointState(OUT PKFLOATING_SAVE Save)
+{
+    return STATUS_SUCCESS;
+}
+
+/*
+ * @implemented
+ */
+NTSTATUS
+NTAPI
+KeRestoreFloatingPointState(IN PKFLOATING_SAVE Save)
+{
+    return STATUS_SUCCESS;
+}
+
+/*
+ * @implemented
+ */
+ULONG
+NTAPI
+KeGetRecommendedSharedDataAlignment(VOID)
+{
+    /* Return the global variable */
+    return KeLargestCacheLine;
+}
+
+/*
+ * @implemented
+ */
+VOID
+NTAPI
+KeFlushEntireTb(IN BOOLEAN Invalid,
+                IN BOOLEAN AllProcessors)
+{
+    KIRQL OldIrql;
+
+    /* Raise the IRQL for the TB Flush */
+    OldIrql = KeRaiseIrqlToSynchLevel();
+
+#ifdef CONFIG_SMP
+    /* FIXME: Support IPI Flush */
+#error Not yet implemented!
+#endif
+
+    /* Flush the TB for the Current CPU */
+    //KeFlushCurrentTb();
+
+    /* Return to Original IRQL */
+    KeLowerIrql(OldIrql);
+}
+
+/*
+ * @implemented
+ */
+VOID
+NTAPI
+KeSetDmaIoCoherency(IN ULONG Coherency)
+{
+    /* Save the coherency globally */
+    KiDmaIoCoherency = Coherency;
+}
+
+/*
+ * @implemented
+ */
+KAFFINITY
+NTAPI
+KeQueryActiveProcessors(VOID)
+{
+    PAGED_CODE();
+
+    /* Simply return the number of active processors */
+    return KeActiveProcessors;
+}
+
+/*
+ * @implemented
+ */
+VOID
+__cdecl
+KeSaveStateForHibernate(IN PKPROCESSOR_STATE State)
+{
+    /* Capture the context */
+    RtlCaptureContext(&State->ContextFrame);
+
+    /* Capture the control state */
+    KiSaveProcessorControlState(State);
+}
diff --git a/reactos/ntoskrnl/ke/powerpc/exp.c b/reactos/ntoskrnl/ke/powerpc/exp.c
new file mode 100644
index 00000000000..148f8efea9b
--- /dev/null
+++ b/reactos/ntoskrnl/ke/powerpc/exp.c
@@ -0,0 +1,114 @@
+/*
+ * PROJECT:         ReactOS Kernel
+ * LICENSE:         GPL - See COPYING in the top level directory
+ * FILE:            ntoskrnl/ke/i386/exp.c
+ * PURPOSE:         Exception Dispatching and Context<->Trap Frame Conversion
+ * PROGRAMMERS:     Alex Ionescu (alex.ionescu@reactos.org)
+ *                  Gregor Anich
+ *                  Skywing (skywing@valhallalegends.com)
+ */
+
+/* INCLUDES ******************************************************************/
+
+#include <ntoskrnl.h>
+#define NDEBUG
+#include <debug.h>
+
+/* FUNCTIONS *****************************************************************/
+
+_SEH_DEFINE_LOCALS(KiCopyInfo)
+{
+    volatile EXCEPTION_RECORD SehExceptRecord;
+};
+
+_SEH_FILTER(KiCopyInformation)
+{
+    _SEH_ACCESS_LOCALS(KiCopyInfo);
+
+    /* Copy the exception records and return to the handler */
+    RtlMoveMemory((PVOID)&_SEH_VAR(SehExceptRecord),
+                  _SEH_GetExceptionPointers()->ExceptionRecord,
+                  sizeof(EXCEPTION_RECORD));
+    return EXCEPTION_EXECUTE_HANDLER;
+}
+
+VOID
+INIT_FUNCTION
+NTAPI
+KeInitExceptions(VOID)
+{
+}
+
+ULONG
+NTAPI
+KiEspFromTrapFrame(IN PKTRAP_FRAME TrapFrame)
+{
+    return 0;
+}
+
+VOID
+NTAPI
+KiEspToTrapFrame(IN PKTRAP_FRAME TrapFrame,
+                 IN ULONG Esp)
+{
+}
+
+ULONG
+NTAPI
+KiSsFromTrapFrame(IN PKTRAP_FRAME TrapFrame)
+{
+    return 0;
+}
+
+VOID
+NTAPI
+KiSsToTrapFrame(IN PKTRAP_FRAME TrapFrame,
+                IN ULONG Ss)
+{
+}
+
+USHORT
+NTAPI
+KiTagWordFnsaveToFxsave(USHORT TagWord)
+{
+    return 0;
+}
+
+VOID
+NTAPI
+KeContextToTrapFrame(IN PCONTEXT Context,
+                     IN OUT PKEXCEPTION_FRAME ExceptionFrame,
+                     IN OUT PKTRAP_FRAME TrapFrame,
+                     IN ULONG ContextFlags,
+                     IN KPROCESSOR_MODE PreviousMode)
+{
+}
+
+VOID
+NTAPI
+KeTrapFrameToContext(IN PKTRAP_FRAME TrapFrame,
+                     IN PKEXCEPTION_FRAME ExceptionFrame,
+                     IN OUT PCONTEXT Context)
+{
+}
+
+VOID
+NTAPI
+KiDispatchException(IN PEXCEPTION_RECORD ExceptionRecord,
+                    IN PKEXCEPTION_FRAME ExceptionFrame,
+                    IN PKTRAP_FRAME TrapFrame,
+                    IN KPROCESSOR_MODE PreviousMode,
+                    IN BOOLEAN FirstChance)
+{
+}
+
+/*
+ * @implemented
+ */
+NTSTATUS
+NTAPI
+KeRaiseUserException(IN NTSTATUS ExceptionCode)
+{
+    return STATUS_SUCCESS;
+}
+
diff --git a/reactos/ntoskrnl/ke/powerpc/kiinit.c b/reactos/ntoskrnl/ke/powerpc/kiinit.c
new file mode 100644
index 00000000000..d4ced4ac5af
--- /dev/null
+++ b/reactos/ntoskrnl/ke/powerpc/kiinit.c
@@ -0,0 +1,322 @@
+/*
+ * PROJECT:         ReactOS Kernel
+ * LICENSE:         GPL - See COPYING in the top level directory
+ * FILE:            ntoskrnl/ke/powerpc/kiinit.c
+ * PURPOSE:         Kernel Initialization for x86 CPUs
+ * PROGRAMMERS:     Alex Ionescu (alex.ionescu@reactos.org)
+ *                  Art Yerkes (ayerkes@speakeasy.net)
+ */
+
+/* INCLUDES *****************************************************************/
+
+#include <ntoskrnl.h>
+#include <reactos/ppcboot.h>
+
+#define NDEBUG
+#include <debug.h>
+#include <ppcdebug.h>
+#include "ppcmmu/mmu.h"
+
+/* GLOBALS *******************************************************************/
+
+/* Ku bit should be set, so that we get the best options for page protection */
+#define PPC_SEG_Ku 0x40000000
+#define PPC_SEG_Ks 0x20000000
+
+extern LOADER_MODULE KeLoaderModules[64];
+extern ULONG KeLoaderModuleCount;
+extern ULONG_PTR MmFreeLdrLastKernelAddress;
+KPRCB PrcbData[MAXIMUM_PROCESSORS];
+
+/* FUNCTIONS *****************************************************************/
+
+/*
+ * Trap frame:
+ * r0 .. r32
+ * lr, ctr, srr0, srr1, dsisr
+ */
+__asm__(".text\n\t"
+	".globl syscall_start\n\t"
+	".globl syscall_end\n\t"
+	".globl KiSystemService\n\t"
+	"syscall_start:\n\t"
+	"mr 2,1\n\t"
+	"lis 1,KiSystemService1@ha\n\t"
+	"addi 1,1,KiSystemService1@l\n\t"
+	"mfsrr0 0\n\t"
+	"mtsrr0 1\n\t"
+	"lis 1,_kernel_trap_stack@ha\n\t"
+	"addi 1,1,_kernel_trap_stack@l\n\t"
+	"subi 1,1,0x100\n\t"
+	"rfi\n\t"
+	"syscall_end:\n\t"
+	".space 4");
+
+extern int syscall_start[], syscall_end;
+
+VOID
+NTAPI
+KiSetupSyscallHandler()
+{
+    paddr_t handler_target;
+    int *source;
+    for(source = syscall_start, handler_target = 0xc00; 
+	source < &syscall_end; 
+	source++, handler_target += sizeof(int))
+	SetPhys(handler_target, *source);
+}
+
+VOID
+NTAPI
+KiInitializePcr(IN ULONG ProcessorNumber,
+                IN PKIPCR Pcr,
+                IN PKTHREAD IdleThread,
+                IN PVOID DpcStack)
+{
+    Pcr->MajorVersion = PCR_MAJOR_VERSION;
+    Pcr->MinorVersion = PCR_MINOR_VERSION;
+    Pcr->CurrentIrql = PASSIVE_LEVEL;
+    Pcr->PrcbData = &PrcbData[ProcessorNumber];
+    Pcr->PrcbData->MajorVersion = PRCB_MAJOR_VERSION;
+    Pcr->PrcbData->MinorVersion = 0;
+    Pcr->PrcbData->Number = 0; /* UP for now */
+    Pcr->PrcbData->SetMember = 1;
+#if DBG
+    Pcr->PrcbData->BuildType = PRCB_BUILD_DEBUG;
+#else
+    Pcr->PrcbData->BuildType = 0;
+#endif
+    Pcr->PrcbData->DpcStack = DpcStack;
+    KiProcessorBlock[ProcessorNumber] = Pcr->PrcbData;
+}
+
+extern ULONG KiGetFeatureBits();
+extern VOID KiSetProcessorType();
+extern VOID KiGetCacheInformation();
+
+VOID
+NTAPI
+KiInitializeKernel(IN PKPROCESS InitProcess,
+                   IN PKTHREAD InitThread,
+                   IN PVOID IdleStack,
+                   IN PKPRCB Prcb,
+                   IN CCHAR Number,
+                   IN PROS_LOADER_PARAMETER_BLOCK LoaderBlock)
+{
+    ULONG FeatureBits;
+    LARGE_INTEGER PageDirectory;
+    PVOID DpcStack;
+
+    /* Detect and set the CPU Type */
+    KiSetProcessorType();
+
+    /* Initialize the Power Management Support for this PRCB */
+    PoInitializePrcb(Prcb);
+
+    /* Get the processor features for the CPU */
+    FeatureBits = KiGetFeatureBits();
+
+    /* Save feature bits */
+    Prcb->FeatureBits = FeatureBits;
+
+    /* Get cache line information for this CPU */
+    KiGetCacheInformation();
+
+    /* Initialize spinlocks and DPC data */
+    KiInitSpinLocks(Prcb, Number);
+
+    /* Check if this is the Boot CPU */
+    if (!Number)
+    {
+        /* Set Node Data */
+        KeNodeBlock[0] = &KiNode0;
+        Prcb->ParentNode = KeNodeBlock[0];
+        KeNodeBlock[0]->ProcessorMask = Prcb->SetMember;
+
+        /* Set boot-level flags */
+        KeProcessorArchitecture = 0;
+        KeProcessorLevel = (USHORT)Prcb->CpuType;
+        KeFeatureBits = FeatureBits;
+
+        /* Set the current MP Master KPRCB to the Boot PRCB */
+        Prcb->MultiThreadSetMaster = Prcb;
+
+        /* Initialize portable parts of the OS */
+        KiInitSystem();
+
+        /* Initialize the Idle Process and the Process Listhead */
+        InitializeListHead(&KiProcessListHead);
+        PageDirectory.QuadPart = 0;
+        KeInitializeProcess(InitProcess,
+                            0,
+                            0xFFFFFFFF,
+                            &PageDirectory,
+			    TRUE);
+        InitProcess->QuantumReset = MAXCHAR;
+    }
+    else
+    {
+        /* FIXME */
+        DPRINT1("SMP Boot support not yet present\n");
+    }
+
+    /* Setup the Idle Thread */
+    KeInitializeThread(InitProcess,
+                       InitThread,
+                       NULL,
+                       NULL,
+                       NULL,
+                       NULL,
+                       NULL,
+                       IdleStack);
+    InitThread->NextProcessor = Number;
+    InitThread->Priority = HIGH_PRIORITY;
+    InitThread->State = Running;
+    InitThread->Affinity = 1 << Number;
+    InitThread->WaitIrql = DISPATCH_LEVEL;
+    InitProcess->ActiveProcessors = 1 << Number;
+
+    /* Set up the thread-related fields in the PRCB */
+    //Prcb->CurrentThread = InitThread;
+    Prcb->NextThread = NULL;
+    //Prcb->IdleThread = InitThread;
+
+    /* Initialize the Kernel Executive */
+    ExpInitializeExecutive(0, (PLOADER_PARAMETER_BLOCK)LoaderBlock);
+
+    /* Only do this on the boot CPU */
+    if (!Number)
+    {
+        /* Calculate the time reciprocal */
+        KiTimeIncrementReciprocal =
+            KiComputeReciprocal(KeMaximumIncrement,
+                                &KiTimeIncrementShiftCount);
+
+        /* Update DPC Values in case they got updated by the executive */
+        Prcb->MaximumDpcQueueDepth = KiMaximumDpcQueueDepth;
+        Prcb->MinimumDpcRate = KiMinimumDpcRate;
+        Prcb->AdjustDpcThreshold = KiAdjustDpcThreshold;
+
+        /* Allocate the DPC Stack */
+        DpcStack = MmCreateKernelStack(FALSE, 0);
+        if (!DpcStack) KeBugCheckEx(NO_PAGES_AVAILABLE, 1, 0, 0, 0);
+        Prcb->DpcStack = DpcStack;
+    }
+
+    /* Free Initial Memory */
+    // MiFreeInitMemory();
+
+    while (1)
+    {
+        LARGE_INTEGER Timeout;
+        Timeout.QuadPart = 0x7fffffffffffffffLL;
+        KeDelayExecutionThread(KernelMode, FALSE, &Timeout);
+    }
+
+    /* Bug Check and loop forever if anything failed */
+    KEBUGCHECK(0);
+    for(;;);
+}
+
+extern int KiPageFaultHandler(int inst, ppc_trap_frame_t *frame);
+
+/* Use this for early boot additions to the page table */
+VOID
+NTAPI
+KiSystemStartup(IN PLOADER_PARAMETER_BLOCK LoaderBlock)
+{
+    ULONG Cpu;
+    ppc_map_info_t info[3];
+    PKIPCR Pcr = (PKIPCR)KPCR_BASE;
+    PKPRCB Prcb;
+
+    __asm__("mr 13,%0" : : "r" (KPCR_BASE));
+
+    /* Set the page fault handler to the kernel */
+    MmuSetPageCallback(KiPageFaultHandler);
+
+    // Make 0xf... special
+    MmuAllocVsid(2, 0x8000);
+    MmuSetVsid(15,16,2);
+
+    /* Get the current CPU */
+    Cpu = KeNumberProcessors;
+    if (!Cpu)
+    {
+	/* We'll allocate a page from the end of the kernel area for KPCR.  This code will probably
+	 * change when we get SMP support.
+	 */
+	info[0].phys = 0;
+	info[0].proc = 2;
+	info[0].addr = (vaddr_t)Pcr;
+	info[0].flags = MMU_KRW_UR;
+	info[1].phys = 0;
+	info[1].proc = 2;
+	info[1].addr = ((vaddr_t)Pcr) + (1 << PAGE_SHIFT);
+	info[1].flags = MMU_KRW_UR;
+	info[2].phys = 0;
+	info[2].proc = 2;
+	info[2].addr = (vaddr_t)KI_USER_SHARED_DATA;
+	info[2].flags = MMU_KRW_UR;
+	MmuMapPage(info, 3);
+    }
+
+    /* Skip initial setup if this isn't the Boot CPU */
+    if (Cpu) goto AppCpuInit;
+
+    /* Initialize the PCR */
+    RtlZeroMemory(Pcr, PAGE_SIZE);
+    KiInitializePcr(Cpu,
+                    Pcr,
+                    &KiInitialThread.Tcb,
+                    KiDoubleFaultStack);
+
+    /* Set us as the current process */
+    KiInitialThread.Tcb.ApcState.Process = &KiInitialProcess.Pcb;
+
+    /* Setup CPU-related fields */
+AppCpuInit:
+    Pcr->Number = Cpu;
+    Pcr->SetMember = 1 << Cpu;
+    Prcb = KeGetCurrentPrcb();
+    Prcb->SetMember = 1 << Cpu;
+
+    /* Initialize the Processor with HAL */
+    HalInitializeProcessor(Cpu, LoaderBlock);
+
+    /* Set active processors */
+    KeActiveProcessors |= Pcr->SetMember;
+    KeNumberProcessors++;
+
+    /* Initialize the Debugger for the Boot CPU */
+    if (!Cpu) KdInitSystem (0, LoaderBlock);
+
+    /* Check for break-in */
+    if (KdPollBreakIn()) 
+    {
+	DbgBreakPointWithStatus(1);
+    }
+
+    /* Raise to HIGH_LEVEL */
+    KfRaiseIrql(HIGH_LEVEL);
+
+    /* Call main kernel intialization */
+    KiInitializeKernel(&KiInitialProcess.Pcb,
+                       &KiInitialThread.Tcb,
+                       P0BootStack,
+                       Prcb,
+                       Cpu,
+                       (PVOID)LoaderBlock);
+}
+
+VOID
+NTAPI
+KiInitMachineDependent(VOID)
+{
+}
+
+void abort()
+{
+    KeBugCheck(0);
+    while(1);
+}
diff --git a/reactos/ntoskrnl/ke/powerpc/main_asm.S b/reactos/ntoskrnl/ke/powerpc/main_asm.S
new file mode 100644
index 00000000000..abec100ce2b
--- /dev/null
+++ b/reactos/ntoskrnl/ke/powerpc/main_asm.S
@@ -0,0 +1,81 @@
+#include <roscfg.h>
+#include <ndk/asm.h>
+
+#define AP_MAGIC (0x12481020)
+
+.global P0BootStack
+.global	KiDoubleFaultStack
+.global _kernel_stack
+.global _kernel_stack_top
+.global _kernel_trap_stack
+.global _kernel_trap_stack_top
+
+	.section .bss
+	.align 12
+
+
+/* guard page for the kernel stack */
+.fill 4096, 1, 0
+
+_kernel_stack:
+.fill 3*4096, 1, 0
+P0BootStack:	
+_kernel_stack_top:
+
+/* guard page for the trap stack */
+.fill 4096, 1, 0
+
+_kernel_trap_stack:
+.fill 3*4096, 1, 0
+_kernel_trap_stack_top:
+
+.fill 3*4096, 1, 0
+KiDoubleFaultStack:	
+	
+	.text
+	.globl NtProcessStartup
+	.globl KiSystemStartup
+	.globl KiRosPrepareForSystemStartup
+	.globl DrawNumber
+	
+NtProcessStartup:
+    lis		30,AP_MAGIC@ha
+    ori		30,30,AP_MAGIC@l
+    cmpw	0,30,3
+    bne		.m1
+
+    /*
+     * Set a normal MSR value
+     */
+    xor		0,0,0     
+    ori		30,0,0x3031
+    mtmsr	30
+
+    /*
+     *  Reserve space for the floating point save area.
+     */
+    addi  1,1,-SIZEOF_FX_SAVE_AREA
+
+    /* Bye bye asm land! */
+    mr		4,3
+    bl		KiRosPrepareForSystemStartup
+		
+.m1:
+    /* Load the initial kernel stack */
+    lis		1,_kernel_stack_top@ha
+    ori		1,1,_kernel_stack_top@l
+    addi	1,1,-SIZEOF_FX_SAVE_AREA
+    
+    /* Call the main kernel initialization */
+    mr		4,3
+    bl		KiRosPrepareForSystemStartup
+
+	.global NtCurrentTeb
+NtCurrentTeb:
+	mr 3,12
+	blr	
+
+        .globl KeSynchronizeExecution
+
+KeSynchronizeExecution: 
+        blr
diff --git a/reactos/ntoskrnl/ke/powerpc/ppc_irq.c b/reactos/ntoskrnl/ke/powerpc/ppc_irq.c
new file mode 100644
index 00000000000..6555d8323bb
--- /dev/null
+++ b/reactos/ntoskrnl/ke/powerpc/ppc_irq.c
@@ -0,0 +1,841 @@
+/* $Id$
+ *
+ * COPYRIGHT:       See COPYING in the top level directory
+ * PROJECT:         ReactOS kernel
+ * FILE:            ntoskrnl/ke/i386/irq.c
+ * PURPOSE:         IRQ handling
+ *
+ * PROGRAMMERS:     David Welch (welch@mcmail.com)
+ */
+
+/*
+ * NOTE: In general the PIC interrupt priority facilities are used to
+ * preserve the NT IRQL semantics, global interrupt disables are only used
+ * to keep the PIC in a consistent state
+ *
+ */
+
+/* INCLUDES ****************************************************************/
+
+#include <ntoskrnl.h>
+#include <ppcmmu/mmu.h>
+
+#define NDEBUG
+#include <internal/debug.h>
+
+KDPC KiExpireTimerDpc;
+extern ULONG KiMaximumDpcQueueDepth;
+extern ULONG KiMinimumDpcRate;
+extern ULONG KiAdjustDpcThreshold;
+extern ULONG KiIdealDpcRate;
+extern LONG KiTickOffset;
+extern ULONG KeMaximumIncrement;
+extern ULONG KeMinimumIncrement;
+extern ULONG KeTimeAdjustment;
+
+/* GLOBALS *****************************************************************/
+
+/* Interrupt handler list */
+
+#define NR_TRAPS 16
+#ifdef CONFIG_SMP
+
+#define INT_NAME2(intnum) KiUnexpectedInterrupt##intnum
+
+#define BUILD_INTERRUPT_HANDLER(intnum) \
+VOID INT_NAME2(intnum)(VOID);
+
+#define D(x,y) \
+  BUILD_INTERRUPT_HANDLER(x##y)
+
+#define D16(x) \
+  D(x,0) D(x,1) D(x,2) D(x,3) \
+  D(x,4) D(x,5) D(x,6) D(x,7) \
+  D(x,8) D(x,9) D(x,A) D(x,B) \
+  D(x,C) D(x,D) D(x,E) D(x,F)
+
+D16(3) D16(4) D16(5) D16(6)
+D16(7) D16(8) D16(9) D16(A)
+D16(B) D16(C) D16(D) D16(E)
+D16(F)
+
+#define L(x,y) \
+  (ULONG)& INT_NAME2(x##y)
+
+#define L16(x) \
+        L(x,0), L(x,1), L(x,2), L(x,3), \
+        L(x,4), L(x,5), L(x,6), L(x,7), \
+        L(x,8), L(x,9), L(x,A), L(x,B), \
+        L(x,C), L(x,D), L(x,E), L(x,F)
+
+static ULONG irq_handler[ROUND_UP(NR_TRAPS, 16)] = {
+  L16(3), L16(4), L16(5), L16(6),
+  L16(7), L16(8), L16(9), L16(A),
+  L16(B), L16(C), L16(D), L16(E)
+};
+
+#undef L
+#undef L16
+#undef D
+#undef D16
+
+#else /* CONFIG_SMP */
+
+void trap_handler_0(void);
+void trap_handler_1(void);
+void trap_handler_2(void);
+void trap_handler_3(void);
+void trap_handler_4(void);
+void trap_handler_5(void);
+void trap_handler_6(void);
+void trap_handler_7(void);
+void trap_handler_8(void);
+void trap_handler_9(void);
+void trap_handler_10(void);
+void trap_handler_11(void);
+void trap_handler_12(void);
+void trap_handler_13(void);
+void trap_handler_14(void);
+void trap_handler_15(void);
+
+static unsigned int trap_handler[NR_TRAPS] __attribute__((unused)) = 
+{
+   (int)&trap_handler_0,
+   (int)&trap_handler_1,
+   (int)&trap_handler_2,
+   (int)&trap_handler_3,
+   (int)&trap_handler_4,
+   (int)&trap_handler_5,
+   (int)&trap_handler_6,
+   (int)&trap_handler_7,
+   (int)&trap_handler_8,
+   (int)&trap_handler_9,
+   (int)&trap_handler_10,
+   (int)&trap_handler_11,
+   (int)&trap_handler_12,
+   (int)&trap_handler_13,
+   (int)&trap_handler_14,
+   (int)&trap_handler_15,
+};
+
+#endif /* CONFIG_SMP */
+
+/*
+ * PURPOSE: Object describing each isr
+ * NOTE: The data in this table is only modified at passsive level but can
+ * be accessed at any irq level.
+ */
+
+typedef struct
+{
+   LIST_ENTRY ListHead;
+   KSPIN_LOCK Lock;
+   ULONG Count;
+}
+ISR_TABLE, *PISR_TABLE;
+
+#ifdef CONFIG_SMP
+static ISR_TABLE IsrTable[NR_TRAPS][MAXIMUM_PROCESSORS];
+#else
+static ISR_TABLE IsrTable[NR_TRAPS][1];
+#endif
+
+#define TAG_ISR_LOCK     TAG('I', 'S', 'R', 'L')
+
+/* FUNCTIONS ****************************************************************/
+
+VOID
+INIT_FUNCTION
+NTAPI
+KeInitInterrupts (VOID)
+{
+   int i, j;
+
+   /*
+    * Setup the IDT entries to point to the interrupt handlers
+    */
+   for (i=0;i<NR_TRAPS;i++)
+     {
+#ifdef CONFIG_SMP
+        for (j = 0; j < MAXIMUM_PROCESSORS; j++)
+#else
+        j = 0;
+#endif
+          {
+            InitializeListHead(&IsrTable[i][j].ListHead);
+            KeInitializeSpinLock(&IsrTable[i][j].Lock);
+            IsrTable[i][j].Count = 0;
+          }
+     }
+}
+
+static VOID
+KeIRQTrapFrameToTrapFrame(PKIRQ_TRAPFRAME IrqTrapFrame,
+                          PKTRAP_FRAME TrapFrame)
+{
+}
+
+static VOID
+KeTrapFrameToIRQTrapFrame(PKTRAP_FRAME TrapFrame,
+                          PKIRQ_TRAPFRAME IrqTrapFrame)
+{
+}
+
+/*
+ * NOTE: On Windows this function takes exactly one parameter and EBP is
+ *       guaranteed to point to KTRAP_FRAME. The function is used only
+ *       by HAL, so there's no point in keeping that prototype.
+ *
+ * @implemented
+ */
+VOID
+STDCALL
+KeUpdateRunTime(IN PKTRAP_FRAME  TrapFrame,
+                IN KIRQL  Irql)
+{
+    PKPRCB Prcb = KeGetCurrentPrcb();
+    PKTHREAD CurrentThread;
+    PKPROCESS CurrentProcess;
+
+    /* Make sure we don't go further if we're in early boot phase. */
+    if (!(Prcb) || !(Prcb->CurrentThread)) return;
+
+    /* Get the current thread and process */
+    CurrentThread = Prcb->CurrentThread;
+    CurrentProcess = CurrentThread->ApcState.Process;
+
+    /* Check if we came from user mode */
+    if (TrapFrame->PreviousMode != KernelMode)
+    {
+        /* Update user times */
+        CurrentThread->UserTime++;
+        InterlockedIncrement((PLONG)&CurrentProcess->UserTime);
+        Prcb->UserTime++;
+    }
+    else
+    {
+        /* Check IRQ */
+        if (Irql > DISPATCH_LEVEL)
+        {
+            /* This was an interrupt */
+            Prcb->InterruptTime++;
+        }
+        else if ((Irql < DISPATCH_LEVEL) || !(Prcb->DpcRoutineActive))
+        {
+            /* This was normal kernel time */
+            CurrentThread->KernelTime++;
+            InterlockedIncrement((PLONG)&CurrentProcess->KernelTime);
+        }
+        else if (Irql == DISPATCH_LEVEL)
+        {
+            /* This was DPC time */
+            Prcb->DpcTime++;
+        }
+
+        /* Update CPU kernel time in all cases */
+        Prcb->KernelTime++;
+   }
+
+    /* Set the last DPC Count and request rate */
+    Prcb->DpcLastCount = Prcb->DpcData[0].DpcCount;
+    Prcb->DpcRequestRate = ((Prcb->DpcData[0].DpcCount - Prcb->DpcLastCount) +
+                             Prcb->DpcRequestRate) / 2;
+
+    /* Check if we should request a DPC */
+    if ((Prcb->DpcData[0].DpcQueueDepth) && !(Prcb->DpcRoutineActive))
+    {
+        /* Request one */
+        HalRequestSoftwareInterrupt(DISPATCH_LEVEL);
+
+        /* Update the depth if needed */
+        if ((Prcb->DpcRequestRate < KiIdealDpcRate) &&
+            (Prcb->MaximumDpcQueueDepth > 1))
+        {
+            /* Decrease the maximum depth by one */
+            Prcb->MaximumDpcQueueDepth--;
+        }
+    }
+    else
+    {
+        /* Decrease the adjustment threshold */
+        if (!(--Prcb->AdjustDpcThreshold))
+        {
+            /* We've hit 0, reset it */
+            Prcb->AdjustDpcThreshold = KiAdjustDpcThreshold;
+
+            /* Check if we've hit queue maximum */
+            if (KiMaximumDpcQueueDepth != Prcb->MaximumDpcQueueDepth)
+            {
+                /* Increase maximum by one */
+                Prcb->MaximumDpcQueueDepth++;
+            }
+        }
+    }
+
+   /*
+    * If we're at end of quantum request software interrupt. The rest
+    * is handled in KiDispatchInterrupt.
+    *
+    * NOTE: If one stays at DISPATCH_LEVEL for a long time the DPC routine
+    * which checks for quantum end will not be executed and decrementing
+    * the quantum here can result in overflow. This is not a problem since
+    * we don't care about the quantum value anymore after the QuantumEnd
+    * flag is set.
+    */
+    if ((CurrentThread->Quantum -= 3) <= 0)
+    {
+        Prcb->QuantumEnd = TRUE;
+        HalRequestSoftwareInterrupt(DISPATCH_LEVEL);
+    }
+}
+
+
+/*
+ * NOTE: On Windows this function takes exactly zero parameters and EBP is
+ *       guaranteed to point to KTRAP_FRAME. Also [esp+0] contains an IRQL.
+ *       The function is used only by HAL, so there's no point in keeping
+ *       that prototype.
+ *
+ * @implemented
+ */
+VOID
+STDCALL
+KeUpdateSystemTime(IN PKTRAP_FRAME TrapFrame,
+                   IN KIRQL Irql,
+                   IN ULONG Increment)
+{
+    LONG OldOffset;
+    LARGE_INTEGER Time;
+    ASSERT(KeGetCurrentIrql() == PROFILE_LEVEL);
+
+    /* Update interrupt time */
+    Time.LowPart = SharedUserData->InterruptTime.LowPart;
+    Time.HighPart = SharedUserData->InterruptTime.High1Time;
+    Time.QuadPart += Increment;
+    SharedUserData->InterruptTime.High2Time = Time.u.HighPart;
+    SharedUserData->InterruptTime.LowPart = Time.u.LowPart;
+    SharedUserData->InterruptTime.High1Time = Time.u.HighPart;
+
+    /* Increase the tick offset */
+    KiTickOffset -= Increment;
+    OldOffset = KiTickOffset;
+
+    /* Check if this isn't a tick yet */
+    if (KiTickOffset > 0)
+    {
+        /* Expire timers */
+        KeInsertQueueDpc(&KiExpireTimerDpc, 0, 0);
+    }
+    else
+    {
+        /* Setup time structure for system time */
+        Time.LowPart = SharedUserData->SystemTime.LowPart;
+        Time.HighPart = SharedUserData->SystemTime.High1Time;
+        Time.QuadPart += KeTimeAdjustment;
+        SharedUserData->SystemTime.High2Time = Time.HighPart;
+        SharedUserData->SystemTime.LowPart = Time.LowPart;
+        SharedUserData->SystemTime.High1Time = Time.HighPart;
+
+        /* Setup time structure for tick time */
+        Time.LowPart = KeTickCount.LowPart;
+        Time.HighPart = KeTickCount.High1Time;
+        Time.QuadPart += 1;
+        KeTickCount.High2Time = Time.HighPart;
+        KeTickCount.LowPart = Time.LowPart;
+        KeTickCount.High1Time = Time.HighPart;
+        SharedUserData->TickCount.High2Time = Time.HighPart;
+        SharedUserData->TickCount.LowPart = Time.LowPart;
+        SharedUserData->TickCount.High1Time = Time.HighPart;
+
+        /* Update tick count in shared user data as well */
+        SharedUserData->TickCountLowDeprecated++;
+
+        /* Queue a DPC that will expire timers */
+        KeInsertQueueDpc(&KiExpireTimerDpc, 0, 0);
+    }
+
+    /* Update process and thread times */
+    if (OldOffset <= 0)
+    {
+        /* This was a tick, calculate the next one */
+        KiTickOffset += KeMaximumIncrement;
+        KeUpdateRunTime(TrapFrame, Irql);
+    }
+}
+
+VOID STDCALL
+KiInterruptDispatch2 (ULONG vector, KIRQL old_level)
+/*
+ * FUNCTION: Calls all the interrupt handlers for a given irq.
+ * ARGUMENTS:
+ *        vector - The number of the vector to call handlers for.
+ *        old_level - The irql of the processor when the irq took place.
+ * NOTES: Must be called at DIRQL.
+ */
+{
+  PKINTERRUPT isr;
+  PLIST_ENTRY current;
+  KIRQL oldlvl;
+  PISR_TABLE CurrentIsr;
+
+  DPRINT("I(0x%.08x, 0x%.08x)\n", vector, old_level);
+
+  /*
+   * Iterate the list until one of the isr tells us its device interrupted
+   */
+  CurrentIsr = &IsrTable[vector][(ULONG)KeGetCurrentProcessorNumber()];
+
+  KiAcquireSpinLock(&CurrentIsr->Lock);
+
+  CurrentIsr->Count++;
+  current = CurrentIsr->ListHead.Flink;
+
+  while (current != &CurrentIsr->ListHead)
+    {
+      isr = CONTAINING_RECORD(current,KINTERRUPT,InterruptListEntry);
+      oldlvl = KeAcquireInterruptSpinLock(isr);
+      if (isr->ServiceRoutine(isr, isr->ServiceContext))
+        {
+          KeReleaseInterruptSpinLock(isr, oldlvl);
+          break;
+        }
+      KeReleaseInterruptSpinLock(isr, oldlvl);
+      current = current->Flink;
+    }
+  KiReleaseSpinLock(&CurrentIsr->Lock);
+}
+
+VOID
+KiInterruptDispatch3 (ULONG vector, PKIRQ_TRAPFRAME Trapframe)
+/*
+ * FUNCTION: Calls the irq specific handler for an irq
+ * ARGUMENTS:
+ *         irq = IRQ that has interrupted
+ */
+{
+   KIRQL old_level;
+   KTRAP_FRAME KernelTrapFrame;
+   PKTHREAD CurrentThread;
+   PKTRAP_FRAME OldTrapFrame=NULL;
+
+   /*
+    * At this point we have interrupts disabled, nothing has been done to
+    * the PIC.
+    */
+
+   KeGetCurrentPrcb()->InterruptCount++;
+
+   /*
+    * Notify the rest of the kernel of the raised irq level. For the
+    * default HAL this will send an EOI to the PIC and alter the IRQL.
+    */
+   if (!HalBeginSystemInterrupt (vector,
+                                 vector,
+                                 &old_level))
+     {
+       return;
+     }
+
+
+   /*
+    * Enable interrupts
+    * NOTE: Only higher priority interrupts will get through
+    */
+   _enable();
+
+#ifndef CONFIG_SMP
+   if (vector == 0)
+   {
+      KeIRQTrapFrameToTrapFrame(Trapframe, &KernelTrapFrame);
+      KeUpdateSystemTime(&KernelTrapFrame, old_level, 100000);
+   }
+   else
+#endif
+   {
+     /*
+      * Actually call the ISR.
+      */
+     KiInterruptDispatch2(vector, old_level);
+   }
+
+   /*
+    * End the system interrupt.
+    */
+   _disable();
+
+   if (old_level==PASSIVE_LEVEL)
+     {
+       HalEndSystemInterrupt (APC_LEVEL, 0);
+
+       CurrentThread = KeGetCurrentThread();
+       if (CurrentThread!=NULL && CurrentThread->ApcState.UserApcPending)
+         {
+           DPRINT("PID: %d, TID: %d CS %04x/%04x\n",
+                  ((PETHREAD)CurrentThread)->ThreadsProcess->UniqueProcessId,
+                  ((PETHREAD)CurrentThread)->Cid.UniqueThread,
+                  Trapframe->Cs,
+                  CurrentThread->TrapFrame ? CurrentThread->TrapFrame->Cs : 0);
+           if (CurrentThread->TrapFrame == NULL)
+             {
+               OldTrapFrame = CurrentThread->TrapFrame;
+               KeIRQTrapFrameToTrapFrame(Trapframe, &KernelTrapFrame);
+               CurrentThread->TrapFrame = &KernelTrapFrame;
+             }
+
+	   _enable();
+           KiDeliverApc(UserMode, NULL, NULL);
+	   _disable();
+
+           ASSERT(KeGetCurrentThread() == CurrentThread);
+           if (CurrentThread->TrapFrame == &KernelTrapFrame)
+             {
+               KeTrapFrameToIRQTrapFrame(&KernelTrapFrame, Trapframe);
+               CurrentThread->TrapFrame = OldTrapFrame;
+             }
+         }
+       KeLowerIrql(PASSIVE_LEVEL);
+     }
+   else
+     {
+       HalEndSystemInterrupt (old_level, 0);
+     }
+
+}
+
+static VOID
+KeDumpIrqList(VOID)
+{
+   PKINTERRUPT current;
+   PLIST_ENTRY current_entry;
+   LONG i, j;
+   KIRQL oldlvl;
+   BOOLEAN printed;
+
+   for (i=0;i<NR_TRAPS;i++)
+     {
+        printed = FALSE;
+        KeRaiseIrql(i,&oldlvl);
+
+        for (j=0; j < KeNumberProcessors; j++)
+          {
+            KiAcquireSpinLock(&IsrTable[i][j].Lock);
+
+            current_entry = IsrTable[i][j].ListHead.Flink;
+            current = CONTAINING_RECORD(current_entry,KINTERRUPT,InterruptListEntry);
+            while (current_entry!=&(IsrTable[i][j].ListHead))
+              {
+                if (printed == FALSE)
+                  {
+                    printed = TRUE;
+                    DPRINT("For irq %x:\n",i);
+                  }
+                DPRINT("   Isr %x\n",current);
+                current_entry = current_entry->Flink;
+                current = CONTAINING_RECORD(current_entry,KINTERRUPT,InterruptListEntry);
+              }
+            KiReleaseSpinLock(&IsrTable[i][j].Lock);
+          }
+        KeLowerIrql(oldlvl);
+     }
+}
+
+/*
+ * @implemented
+ */
+BOOLEAN 
+STDCALL
+KeConnectInterrupt(PKINTERRUPT InterruptObject)
+{
+   KIRQL oldlvl,synch_oldlvl;
+   PKINTERRUPT ListHead;
+   ULONG Vector;
+   PISR_TABLE CurrentIsr;
+   BOOLEAN Result;
+
+   DPRINT("KeConnectInterrupt()\n");
+
+   Vector = InterruptObject->Vector;
+
+   if (Vector < 0 || Vector >= NR_TRAPS)
+      return FALSE;
+
+   ASSERT (InterruptObject->Number < KeNumberProcessors);
+
+   KeSetSystemAffinityThread(1 << InterruptObject->Number);
+
+   CurrentIsr = &IsrTable[Vector][(ULONG)InterruptObject->Number];
+
+   KeRaiseIrql(Vector,&oldlvl);
+   KiAcquireSpinLock(&CurrentIsr->Lock);
+
+   /*
+    * Check if the vector is already in use that we can share it
+    */
+   if (!IsListEmpty(&CurrentIsr->ListHead))
+   {
+      ListHead = CONTAINING_RECORD(CurrentIsr->ListHead.Flink,KINTERRUPT,InterruptListEntry);
+      if (InterruptObject->ShareVector == FALSE || ListHead->ShareVector==FALSE)
+      {
+         KiReleaseSpinLock(&CurrentIsr->Lock);
+         KeLowerIrql(oldlvl);
+         KeRevertToUserAffinityThread();
+         return FALSE;
+      }
+   }
+
+   synch_oldlvl = KeAcquireInterruptSpinLock(InterruptObject);
+
+   DPRINT("%x %x\n",CurrentIsr->ListHead.Flink, CurrentIsr->ListHead.Blink);
+
+   Result = HalEnableSystemInterrupt(Vector, InterruptObject->Irql, InterruptObject->Mode);
+   if (Result)
+   {
+      InsertTailList(&CurrentIsr->ListHead,&InterruptObject->InterruptListEntry);
+      DPRINT("%x %x\n",InterruptObject->InterruptListEntry.Flink, InterruptObject->InterruptListEntry.Blink);
+   }
+
+   InterruptObject->Connected = TRUE;
+   KeReleaseInterruptSpinLock(InterruptObject, synch_oldlvl);
+
+   /*
+    * Release the table spinlock
+    */
+   KiReleaseSpinLock(&CurrentIsr->Lock);
+   KeLowerIrql(oldlvl);
+
+   KeDumpIrqList();
+
+   KeRevertToUserAffinityThread();
+
+   return Result;
+}
+
+/*
+ * @implemented
+ *
+ * FUNCTION: Releases a drivers isr
+ * ARGUMENTS:
+ *        InterruptObject = isr to release
+ */
+BOOLEAN 
+STDCALL
+KeDisconnectInterrupt(PKINTERRUPT InterruptObject)
+{
+    KIRQL oldlvl,synch_oldlvl;
+    PISR_TABLE CurrentIsr;
+    BOOLEAN State;
+
+    DPRINT1("KeDisconnectInterrupt\n");
+    ASSERT (InterruptObject->Number < KeNumberProcessors);
+
+    /* Set the affinity */
+    KeSetSystemAffinityThread(1 << InterruptObject->Number);
+
+    /* Get the ISR Tabe */
+    CurrentIsr = &IsrTable[InterruptObject->Vector]
+                          [(ULONG)InterruptObject->Number];
+
+    /* Raise IRQL to required level and lock table */
+    KeRaiseIrql(InterruptObject->Vector,&oldlvl);
+    KiAcquireSpinLock(&CurrentIsr->Lock);
+
+    /* Check if it's actually connected */
+    if ((State = InterruptObject->Connected))
+    {
+        /* Lock the Interrupt */
+        synch_oldlvl = KeAcquireInterruptSpinLock(InterruptObject);
+
+        /* Remove this one, and check if all are gone */
+        RemoveEntryList(&InterruptObject->InterruptListEntry);
+        if (IsListEmpty(&CurrentIsr->ListHead))
+        {
+            /* Completely Disable the Interrupt */
+            HalDisableSystemInterrupt(InterruptObject->Vector, InterruptObject->Irql);
+        }
+        
+        /* Disconnect it */
+        InterruptObject->Connected = FALSE;
+    
+        /* Release the interrupt lock */
+        KeReleaseInterruptSpinLock(InterruptObject, synch_oldlvl);
+    }
+    /* Release the table spinlock */
+    KiReleaseSpinLock(&CurrentIsr->Lock);
+    KeLowerIrql(oldlvl);
+
+    /* Go back to default affinity */
+    KeRevertToUserAffinityThread();
+    
+    /* Return Old Interrupt State */
+    return State;
+}
+
+/*
+ * @implemented
+ */
+VOID
+STDCALL
+KeInitializeInterrupt(PKINTERRUPT Interrupt,
+                      PKSERVICE_ROUTINE ServiceRoutine,
+                      PVOID ServiceContext,
+                      PKSPIN_LOCK SpinLock,
+                      ULONG Vector,
+                      KIRQL Irql,
+                      KIRQL SynchronizeIrql,
+                      KINTERRUPT_MODE InterruptMode,
+                      BOOLEAN ShareVector,
+                      CHAR ProcessorNumber,
+                      BOOLEAN FloatingSave)
+{
+    /* Set the Interrupt Header */
+    Interrupt->Type = InterruptObject;
+    Interrupt->Size = sizeof(KINTERRUPT);
+    
+    /* Check if we got a spinlock */
+    if (SpinLock)
+    {
+        Interrupt->ActualLock = SpinLock;
+    }
+    else
+    {
+        /* This means we'll be usin the built-in one */
+        KeInitializeSpinLock(&Interrupt->SpinLock);
+        Interrupt->ActualLock = &Interrupt->SpinLock;
+    }
+    
+    /* Set the other settings */
+    Interrupt->ServiceRoutine = ServiceRoutine;
+    Interrupt->ServiceContext = ServiceContext;
+    Interrupt->Vector = Vector;
+    Interrupt->Irql = Irql;
+    Interrupt->SynchronizeIrql = SynchronizeIrql;
+    Interrupt->Mode = InterruptMode;
+    Interrupt->ShareVector = ShareVector;
+    Interrupt->Number = ProcessorNumber;
+    Interrupt->FloatingSave = FloatingSave;
+    
+    /* Disconnect it at first */
+    Interrupt->Connected = FALSE;
+}
+
+VOID KePrintInterruptStatistic(VOID)
+{
+   LONG i, j;
+
+   for (j = 0; j < KeNumberProcessors; j++)
+   {
+      DPRINT1("CPU%d:\n", j);
+      for (i = 0; i < NR_TRAPS; i++)
+      {
+         if (IsrTable[i][j].Count)
+         {
+             DPRINT1("  Irq %x(%d): %d\n", i, i, IsrTable[i][j].Count);
+         }
+      }
+   }
+}
+
+BOOLEAN
+NTAPI
+KeDisableInterrupts(VOID)
+{
+    ULONG Flags = 0;
+    BOOLEAN Return;
+
+    Flags = __readmsr();
+    Return = (Flags & 0x8000) ? TRUE: FALSE;
+
+    /* Disable interrupts */
+    _disable();
+    return Return;
+}
+
+ULONG
+NTAPI
+KdpServiceDispatcher(ULONG Service, PCHAR Buffer, ULONG Length);
+
+__asm__(".globl KiSystemService\n\t"
+	".globl KiSystemService1\n\t"
+	".globl kiss_proceed\n\t"
+	".globl kiss_end\n"
+	"KiSystemService1:\n\t"
+	"stw 2,4(1)\n\t" // r1
+	"stw 3,12(1)\n\t"
+	"stw 4,16(1)\n\t"
+	"stw 5,20(1)\n\t"
+	"stw 6,24(1)\n\t"
+	"stw 7,28(1)\n\t"
+	"stw 8,32(1)\n\t"
+	"stw 9,36(1)\n\t"
+	"stw 10,40(1)\n\t"
+	"stw 11,44(1)\n\t"
+	"stw 12,48(1)\n\t"
+	"stw 13,52(1)\n\t"
+	"stw 14,56(1)\n\t"
+	"stw 15,60(1)\n\t"
+	"stw 16,64(1)\n\t"
+	"stw 17,68(1)\n\t"
+	"stw 18,72(1)\n\t"
+	"stw 19,76(1)\n\t"
+	"stw 20,80(1)\n\t"
+	"stw 21,84(1)\n\t"
+	"stw 22,88(1)\n\t"
+	"stw 23,92(1)\n\t"
+	"stw 24,96(1)\n\t"
+	"stw 25,100(1)\n\t"
+	"stw 26,104(1)\n\t"
+	"stw 27,108(1)\n\t"
+	"stw 28,112(1)\n\t"
+	"stw 29,116(1)\n\t"
+	"stw 30,120(1)\n\t"
+	"stw 31,124(1)\n\t"
+	/* This save is important */
+	"stw 0,140(1)\n\t" // srr0
+	"mflr 0\n\t"
+	"stw 0,128(1)\n\t"
+	"mfctr 0\n\t"
+	"stw 0,136(1)\n\t"
+	"mfsrr1 0\n\t"
+	"stw 0,144(1)\n\t"
+	"mfdsisr 0\n\t"
+	"stw 0,148(1)\n\t"
+	"mfdar 0\n\t"
+	"stw 0,152(1)\n\t"
+	"lis 3,KiSystemService@ha\n\t"
+	"addi 3,3,KiSystemService@l\n\t"
+	"mtctr 3\n\t"
+	"mr 3,1\n\t"
+	"subi 1,1,0x100\n\t"
+	"bctrl\n\t"
+	"addi 1,1,0x100\n\t"
+	/* Return from kernel */
+	"lwz 3,12(1)\n\t" /* Result */
+	"lwz 0,128(1)\n\t"
+	"mtlr 0\n\t"
+	"lwz 0,140(1)\n\t"
+	"mtsrr0 0\n\t"
+	"lwz 0,144(1)\n\t"
+	"mtsrr1 0\n\t"
+	"lwz 1,4(1)\n"    /* Stack */
+	"rfi\n");
+	
+VOID
+NTAPI
+KiSystemService(ppc_trap_frame_t *trap_frame)
+{
+    int i;
+    switch(trap_frame->gpr[8])
+    {
+    case 0x10000: /* DebugService */
+	for( i = 0; i < trap_frame->gpr[5]; i++ )
+	    SetPhysByte(0x800003f8, ((PCHAR)trap_frame->gpr[4])[i]);
+
+	trap_frame->gpr[3] = KdpServiceDispatcher
+	    (trap_frame->gpr[3], 
+	     (PCHAR)trap_frame->gpr[4],
+	     trap_frame->gpr[5]);
+	break;
+    }
+}
+
+/* EOF */
diff --git a/reactos/ntoskrnl/ke/powerpc/stubs.c b/reactos/ntoskrnl/ke/powerpc/stubs.c
new file mode 100644
index 00000000000..1cc2bee5785
--- /dev/null
+++ b/reactos/ntoskrnl/ke/powerpc/stubs.c
@@ -0,0 +1,234 @@
+/*
+ * PROJECT:         ReactOS Kernel
+ * LICENSE:         GPL - See COPYING in the top level directory
+ * FILE:            ntoskrnl/vdm/vdmmain.c
+ * PURPOSE:         VDM Support Services
+ * PROGRAMMERS:     Alex Ionescu (alex.ionescu@reactos.org)
+ */
+
+/* INCLUDES ******************************************************************/
+
+#include <ntoskrnl.h>
+#define NDEBUG
+#include <debug.h>
+
+NTSTATUS
+NTAPI
+NtVdmControl(IN ULONG ControlCode,
+             IN PVOID ControlData)
+{
+    return STATUS_UNSUCCESSFUL;
+}
+
+NTSTATUS
+NTAPI
+Ke386CallBios(IN ULONG Int,
+              OUT PCONTEXT Context)
+{
+    return STATUS_UNSUCCESSFUL;
+}
+
+VOID
+NTAPI
+KiUnexpectedInterrupt()
+{
+}
+
+LONG NTAPI Exi386InterlockedDecrementLong(PLONG Addend)
+{
+    return _InterlockedIncrement(Addend);
+}
+
+LONG NTAPI Exi386InterlockedIncrementLong(PLONG Addend)
+{
+    return _InterlockedDecrement(Addend);
+}
+
+LONG NTAPI Exi386InterlockedExchangeUlong(PLONG Target, LONG Exch, LONG Compare)
+{
+    return _InterlockedCompareExchange(Target, Exch, Compare);
+}
+
+/*
+ * @unimplemented
+ */
+NTSTATUS
+NTAPI
+KeI386FlatToGdtSelector(IN ULONG Base,
+                        IN USHORT Length,
+                        IN USHORT Selector)
+{
+    UNIMPLEMENTED;
+    return 0;
+}
+
+/*
+ * @unimplemented
+ */
+NTSTATUS
+NTAPI
+KeI386ReleaseGdtSelectors(OUT PULONG SelArray,
+                          IN ULONG NumOfSelectors)
+{
+    UNIMPLEMENTED;
+    return 0;
+}
+
+/*
+ * @unimplemented
+ */
+NTSTATUS
+NTAPI
+KeI386AllocateGdtSelectors(OUT PULONG SelArray,
+                           IN ULONG NumOfSelectors)
+{
+    UNIMPLEMENTED;
+    return 0;
+}
+
+VOID
+NTAPI
+KeDumpStackFrames(PULONG Frame)
+{
+}
+
+LONG
+NTAPI
+Kei386EoiHelper() { return 0; }
+
+NTSTATUS
+NTAPI
+KeUserModeCallback(IN ULONG RoutineIndex,
+                   IN PVOID Argument,
+                   IN ULONG ArgumentLength,
+                   OUT PVOID *Result,
+                   OUT PULONG ResultLength)
+{
+    return STATUS_UNSUCCESSFUL;
+}
+
+VOID
+NTAPI
+KiCoprocessorError() { }
+
+VOID
+NTAPI
+KiDispatchInterrupt() { }
+
+VOID
+NTAPI
+KiInitializeUserApc(IN PKEXCEPTION_FRAME ExceptionFrame,
+                    IN PKTRAP_FRAME TrapFrame,
+                    IN PKNORMAL_ROUTINE NormalRoutine,
+                    IN PVOID NormalContext,
+                    IN PVOID SystemArgument1,
+                    IN PVOID SystemArgument2)
+{
+}
+
+PVOID
+NTAPI
+KeSwitchKernelStack(PVOID StackBase, PVOID StackLimit)
+{
+    return NULL;
+}
+
+VOID
+NTAPI
+KiSwapProcess(struct _KPROCESS *NewProcess, struct _KPROCESS *OldProcess)
+{
+}
+
+BOOLEAN
+NTAPI
+KiSwapContext(PKTHREAD CurrentThread, PKTHREAD NewThread)
+{
+    return FALSE;
+}
+
+NTSTATUS
+NTAPI
+Mmi386ReleaseMmInfo(PEPROCESS Process)
+{
+    return STATUS_UNSUCCESSFUL;
+}
+
+VOID
+NTAPI
+KeI386VdmInitialize(VOID)
+{
+}
+
+NTSYSAPI
+NTSTATUS 
+NTAPI 
+NtCallbackReturn
+( IN PVOID Result OPTIONAL, IN ULONG ResultLength, IN NTSTATUS Status )
+{
+    return STATUS_UNSUCCESSFUL;
+}
+
+NTSYSAPI 
+NTSTATUS
+NTAPI
+NtContinue
+(IN PCONTEXT ThreadContext, IN BOOLEAN RaiseAlert)
+{
+    return STATUS_UNSUCCESSFUL;
+}
+
+NTSYSAPI
+ULONG
+NTAPI
+NtGetTickCount() { return __rdtsc(); }
+
+NTSTATUS
+STDCALL
+NtSetLdtEntries 
+(ULONG Selector1, LDT_ENTRY LdtEntry1, ULONG Selector2, LDT_ENTRY LdtEntry2)
+{
+    return STATUS_UNSUCCESSFUL;
+}
+
+NTSYSAPI 
+NTSTATUS
+NTAPI
+NtRaiseException
+(IN PEXCEPTION_RECORD ExceptionRecord, IN PCONTEXT ThreadContext, IN BOOLEAN HandleException )
+{
+    return STATUS_UNSUCCESSFUL;
+}
+
+VOID
+STDCALL
+KiThreadStartup(PKSYSTEM_ROUTINE SystemRoutine,
+                PKSTART_ROUTINE StartRoutine,
+                PVOID StartContext,
+                BOOLEAN UserThread,
+                KTRAP_FRAME TrapFrame)
+{
+}
+
+void _alldiv() { }
+
+void _alldvrm() { }
+
+void _allmul() { }
+
+void _alloca_probe() { }
+
+void _allrem() { }
+
+void _allshl() { }
+
+void _allshr() { }
+
+void _aulldiv() { }
+
+void _aulldvrm() { }
+
+void _aullrem() { }
+
+void _aullshr() { }
+
+void _abnormal_termination() { }
diff --git a/reactos/ntoskrnl/ke/powerpc/systimer.c b/reactos/ntoskrnl/ke/powerpc/systimer.c
new file mode 100644
index 00000000000..3a85f7c40c3
--- /dev/null
+++ b/reactos/ntoskrnl/ke/powerpc/systimer.c
@@ -0,0 +1,21 @@
+/*
+ * PROJECT:         ReactOS Kernel
+ * LICENSE:         GPL - See COPYING in the top level directory
+ * FILE:            ntoskrnl/ke/powerpc/kiinit.c
+ * PURPOSE:         Kernel Initialization for x86 CPUs
+ * PROGRAMMERS:     Art Yerkes (ayerkes@speakeasy.net)
+ */
+
+/* INCLUDES *****************************************************************/
+
+#include <ntoskrnl.h>
+#define NDEBUG
+#include <debug.h>
+#include <ppcdebug.h>
+
+ULONG
+NTAPI
+KiComputeTimerTableIndex(LONGLONG Timer)
+{
+    return 0; // XXX arty fixme
+}
diff --git a/reactos/ntoskrnl/ke/profobj.c b/reactos/ntoskrnl/ke/profobj.c
index 1ebea2378d7..479524a43eb 100644
--- a/reactos/ntoskrnl/ke/profobj.c
+++ b/reactos/ntoskrnl/ke/profobj.c
@@ -233,6 +233,7 @@ KiParseProfileList(IN PKTRAP_FRAME TrapFrame,
     LIST_FOR_EACH(Profile, ListHead, KPROFILE, ProfileListEntry)
     {
         /* Check if the source is good, and if it's within the range */
+#ifdef _M_IX86
         if ((Profile->Source != Source) ||
             (TrapFrame->Eip < (ULONG_PTR)Profile->RangeBase) ||
             (TrapFrame->Eip > (ULONG_PTR)Profile->RangeLimit)) {
@@ -244,6 +245,9 @@ KiParseProfileList(IN PKTRAP_FRAME TrapFrame,
         BucketValue = (PULONG)((((ULONG_PTR)Profile->Buffer +
                                (TrapFrame->Eip - (ULONG_PTR)Profile->RangeBase))
                                 >> Profile->BucketShift) &~ 0x3);
+#elif defined(_M_PPC) 
+    // XXX arty
+#endif
 
         /* Increment the value */
         ++BucketValue;
diff --git a/reactos/ntoskrnl/mm/mm.c b/reactos/ntoskrnl/mm/mm.c
index db13c016406..418cd46357c 100644
--- a/reactos/ntoskrnl/mm/mm.c
+++ b/reactos/ntoskrnl/mm/mm.c
@@ -298,12 +298,14 @@ MmAccessFault(IN BOOLEAN StoreInstruction,
     /* Cute little hack for ROS */
     if ((ULONG_PTR)Address >= (ULONG_PTR)MmSystemRangeStart)
     {
+#ifdef _M_IX86
         /* Check for an invalid page directory in kernel mode */
         if (Mmi386MakeKernelPageTableGlobal(Address))
         {
             /* All is well with the world */
             return STATUS_SUCCESS;
         }
+#endif
     }
 
     /* Keep same old ReactOS Behaviour */
diff --git a/reactos/ntoskrnl/mm/pagefile.c b/reactos/ntoskrnl/mm/pagefile.c
index 15c60ed000c..7c3afcf3987 100644
--- a/reactos/ntoskrnl/mm/pagefile.c
+++ b/reactos/ntoskrnl/mm/pagefile.c
@@ -579,12 +579,14 @@ MmDumpToPagingFile(ULONG BugCode,
    Headers->Type = MmCoreDumpType;
    if (TrapFrame != NULL)
    {
+#ifdef _M_IX86
       if (!(TrapFrame->EFlags & (1 << 17)))
       {
          memcpy(&Headers->TrapFrame, TrapFrame,
                 sizeof(KTRAP_FRAME) - (4 * sizeof(ULONG)));
       }
       else
+#endif
       {
          memcpy(&Headers->TrapFrame, TrapFrame, sizeof(KTRAP_FRAME));
       }
diff --git a/reactos/ntoskrnl/mm/powerpc/page.c b/reactos/ntoskrnl/mm/powerpc/page.c
new file mode 100644
index 00000000000..d1e5e90ea8a
--- /dev/null
+++ b/reactos/ntoskrnl/mm/powerpc/page.c
@@ -0,0 +1,630 @@
+/* $Id: page.c 23907 2006-09-04 05:52:23Z arty $
+ *
+ * COPYRIGHT:       See COPYING in the top level directory
+ * PROJECT:         ReactOS kernel
+ * FILE:            ntoskrnl/mm/i386/page.c
+ * PURPOSE:         Low level memory managment manipulation
+ *
+ * PROGRAMMERS:     David Welch (welch@cwcom.net)
+ * Revised for PowerPC by arty
+ */
+
+/* INCLUDES ***************************************************************/
+
+#include <ntoskrnl.h>
+#include <ppcmmu/mmu.h>
+#define NDEBUG
+#include <internal/debug.h>
+
+#if defined (ALLOC_PRAGMA)
+#pragma alloc_text(INIT, MmInitGlobalKernelPageDirectory)
+#pragma alloc_text(INIT, MiInitPageDirectoryMap)
+#endif
+
+/* GLOBALS *****************************************************************/
+
+#define HYPERSPACE_PAGEDIR_PTR  ((PVOID)0xc0000000)
+
+#define PA_PRESENT (1ll<<63)
+#define PA_USER (1ll<<62)
+#define PA_ACCESSED 0x200
+#define PA_DIRTY 0x100
+#define PA_WT 0x20
+#define PA_CD 0x10
+#define PA_READWRITE 3
+
+#define HYPERSPACE		(0xc0400000)
+#define IS_HYPERSPACE(v)	(((ULONG)(v) >= HYPERSPACE && (ULONG)(v) < HYPERSPACE + 0x400000))
+
+#define PTE_TO_PFN(X)  ((X) >> PAGE_SHIFT)
+#define PFN_TO_PTE(X)  ((X) << PAGE_SHIFT)
+
+#if defined(__GNUC__)
+#define PTE_TO_PAGE(X) ((LARGE_INTEGER)(LONGLONG)(PAGE_MASK(X)))
+#else
+__inline LARGE_INTEGER PTE_TO_PAGE(ULONG npage)
+{
+   LARGE_INTEGER dummy;
+   dummy.QuadPart = (LONGLONG)(PAGE_MASK(npage));
+   return dummy;
+}
+#endif
+
+/* FUNCTIONS ***************************************************************/
+
+VOID
+STDCALL
+MiFlushTlbIpiRoutine(PVOID Address)
+{
+   if (Address == (PVOID)0xffffffff)
+   {
+      __asm__("tlbsync");
+   }
+   else if (Address == (PVOID)0xfffffffe)
+   {
+      __asm__("tlbsync");
+   }
+   else
+   {
+      __asm__("tlbi %0" : "=r" (Address));
+   }
+}
+
+VOID
+MiFlushTlb(PULONG Pt, PVOID Address)
+{
+    __asm__("tlbi %0" : "=r" (Address));
+}
+
+
+
+PULONG
+MmGetPageDirectory(VOID)
+{
+   unsigned int page_dir=0;
+   return((PULONG)page_dir);
+}
+
+static ULONG
+ProtectToFlags(ULONG flProtect)
+{
+    return MMU_ALL_RW; // XXX hack
+}
+
+NTSTATUS
+STDCALL
+MmCopyMmInfo(PEPROCESS Src,
+             PEPROCESS Dest,
+             PPHYSICAL_ADDRESS DirectoryTableBase)
+{
+    DPRINT("MmCopyMmInfo(Src %x, Dest %x)\n", Src, Dest);
+
+    KeBugCheck(0);
+    
+    return(STATUS_SUCCESS);
+}
+
+NTSTATUS
+NTAPI
+MmInitializeHandBuiltProcess(IN PEPROCESS Process,
+                             IN PLARGE_INTEGER DirectoryTableBase)
+{
+    /* Share the directory base with the idle process */
+    *DirectoryTableBase = PsGetCurrentProcess()->Pcb.DirectoryTableBase;
+    
+    /* Initialize the Addresss Space */
+    MmInitializeAddressSpace(Process, (PMADDRESS_SPACE)&Process->VadRoot);
+    
+    /* The process now has an address space */
+    Process->HasAddressSpace = TRUE;
+    return STATUS_SUCCESS;
+}
+
+BOOLEAN
+STDCALL
+MmCreateProcessAddressSpace(IN ULONG MinWs,
+                            IN PEPROCESS Process,
+                            IN PLARGE_INTEGER DirectoryTableBase)
+{
+    KeBugCheck(0);
+    return TRUE;
+}
+
+VOID
+NTAPI
+MmDeletePageTable(PEPROCESS Process, PVOID Address)
+{
+    PEPROCESS CurrentProcess = PsGetCurrentProcess();
+
+    if(!CurrentProcess) return;
+	
+    MmuRevokeVsid((paddr_t)Process->UniqueProcessId, -1);
+}
+
+VOID
+NTAPI
+MmFreePageTable(PEPROCESS Process, PVOID Address)
+{
+    MmDeletePageTable(Process, Address);
+}
+
+PVOID
+NTAPI
+MmGetPhysicalAddressProcess(PEPROCESS Process, PVOID Addr)
+{
+    ppc_map_info_t info = { 0 };
+    info.proc = Process ? (int)Process->UniqueProcessId : 0;
+    info.addr = (vaddr_t)Addr;
+    MmuInqPage(&info, 1);
+    return (PVOID)info.phys;
+}
+
+/*
+ * @implemented
+ */
+PHYSICAL_ADDRESS STDCALL
+MmGetPhysicalAddress(PVOID vaddr)
+/*
+ * FUNCTION: Returns the physical address corresponding to a virtual address
+ */
+{
+    PHYSICAL_ADDRESS Addr;
+    Addr.QuadPart = (ULONG)MmGetPhysicalAddressProcess(PsGetCurrentProcess()->UniqueProcessId, vaddr);
+    return Addr;
+}
+
+PFN_TYPE
+NTAPI
+MmGetPfnForProcess(PEPROCESS Process,
+                   PVOID Address)
+{
+    return((PFN_TYPE)MmGetPhysicalAddressProcess(Process, Address) >> PAGE_SHIFT);
+}
+
+VOID
+NTAPI
+MmDisableVirtualMapping(PEPROCESS Process, PVOID Address, BOOLEAN* WasDirty, PPFN_TYPE Page)
+/*
+ * FUNCTION: Delete a virtual mapping
+ */
+{
+    ppc_map_info_t info = { 0 };
+    info.proc = Process ? (int)Process->UniqueProcessId : 0;
+    info.addr = (vaddr_t)Address;
+    MmuUnmapPage(&info, 1);
+}
+
+VOID
+NTAPI
+MmRawDeleteVirtualMapping(PVOID Address)
+{
+}
+
+VOID
+NTAPI
+MmDeleteVirtualMapping(PEPROCESS Process, PVOID Address, BOOLEAN FreePage,
+                       BOOLEAN* WasDirty, PPFN_TYPE Page)
+/*
+ * FUNCTION: Delete a virtual mapping
+ */
+{
+    ppc_map_info_t info = { 0 };
+    
+    DPRINT("MmDeleteVirtualMapping(%x, %x, %d, %x, %x)\n",
+	   Process, Address, FreePage, WasDirty, Page);
+    
+    info.proc = Process ? (int)Process->UniqueProcessId : 0;
+    info.addr = (vaddr_t)Address;
+    MmuInqPage(&info, 1);
+
+    if (FreePage && info.phys)
+    {
+	MmReleasePageMemoryConsumer(MC_NPPOOL, info.phys >> PAGE_SHIFT);
+    }
+    
+    /*
+     * Return some information to the caller
+     */
+    if (WasDirty != NULL)
+    {
+	*WasDirty = !!(info.flags & MMU_PAGE_DIRTY);
+    }
+    if (Page != NULL)
+    {
+	*Page = info.phys >> PAGE_SHIFT;
+    }
+}
+
+VOID
+NTAPI
+MmDeletePageFileMapping(PEPROCESS Process, PVOID Address,
+                        SWAPENTRY* SwapEntry)
+/*
+ * FUNCTION: Delete a virtual mapping
+ */
+{
+    ppc_map_info_t info = { 0 };
+    /*
+     * Decrement the reference count for this page table.
+     */
+    if (Process != NULL &&
+	((PMADDRESS_SPACE)&Process->VadRoot)->PageTableRefCountTable != NULL &&
+	Address < MmSystemRangeStart)
+    {
+	PUSHORT Ptrc;
+	
+	Ptrc = ((PMADDRESS_SPACE)&Process->VadRoot)->PageTableRefCountTable;
+	MmFreePageTable(Process, Address);
+    }
+        
+    /*
+     * Return some information to the caller
+     */
+    MmuInqPage(&info, 1);
+    *SwapEntry = info.phys;
+}
+
+BOOLEAN
+NTAPI
+MmIsDirtyPage(PEPROCESS Process, PVOID Address)
+{
+    ppc_map_info_t info = { 0 };
+    info.proc = Process ? (int)Process->UniqueProcessId : 0;
+    info.addr = (vaddr_t)Address;
+    MmuInqPage(&info, 1);
+    return !!(info.flags & MMU_PAGE_DIRTY);
+}
+
+BOOLEAN
+NTAPI
+MmIsAccessedAndResetAccessPage(PEPROCESS Process, PVOID Address)
+{
+    ppc_map_info_t info = { 0 };
+
+    if (Address < MmSystemRangeStart && Process == NULL)
+    {
+	DPRINT1("MmIsAccessedAndResetAccessPage is called for user space without a process.\n");
+	KEBUGCHECK(0);
+    }
+
+    info.proc = Process ? (int)Process->UniqueProcessId : 0;
+    info.addr = (vaddr_t)Address;
+    MmuInqPage(&info, 1);
+    return !!(info.flags /*& MMU_PAGE_ACCESS*/);
+}
+
+VOID
+NTAPI
+MmSetCleanPage(PEPROCESS Process, PVOID Address)
+{
+}
+
+VOID
+NTAPI
+MmSetDirtyPage(PEPROCESS Process, PVOID Address)
+{
+}
+
+VOID
+NTAPI
+MmEnableVirtualMapping(PEPROCESS Process, PVOID Address)
+{
+}
+
+BOOLEAN
+NTAPI
+MmIsPagePresent(PEPROCESS Process, PVOID Address)
+{
+    ppc_map_info_t info = { 0 };
+    info.proc = Process ? (int)Process->UniqueProcessId : 0;
+    info.addr = (vaddr_t)Address;
+    MmuInqPage(&info, 1);
+    return !!info.phys;
+}
+
+ULONGLONG MmGetPageEntryForProcess(PEPROCESS Process, PVOID Address)
+{
+    return 0; // XXX arty
+}
+
+BOOLEAN
+NTAPI
+MmIsPageSwapEntry(PEPROCESS Process, PVOID Address)
+{
+    ULONG Entry;
+    Entry = MmGetPageEntryForProcess(Process, Address);
+    return !(Entry & PA_PRESENT) && Entry != 0 ? TRUE : FALSE;
+}
+
+NTSTATUS
+NTAPI
+MmCreateVirtualMappingForKernel(PVOID Address,
+                                ULONG flProtect,
+                                PPFN_TYPE Pages,
+				ULONG PageCount)
+{
+    ULONG i;
+    PVOID Addr;
+    
+    DPRINT("MmCreateVirtualMappingForKernel(%x, %x, %x, %d)\n",
+           Address, flProtect, Pages, PageCount);
+    
+    if (Address < MmSystemRangeStart)
+    {
+	DPRINT1("MmCreateVirtualMappingForKernel is called for user space\n");
+	KEBUGCHECK(0);
+    }
+    
+    Addr = Address;
+    
+    for (i = 0; i < PageCount; i++, Addr = (PVOID)((ULONG_PTR)Addr + PAGE_SIZE))
+    {
+#if 0
+	if (!(Attributes & PA_PRESENT) && Pages[i] != 0)
+	{
+            DPRINT1("Setting physical address but not allowing access at address "
+                    "0x%.8X with attributes %x/%x.\n",
+                    Addr, Attributes, flProtect);
+            KEBUGCHECK(0);
+	}
+	(void)InterlockedExchangeUL(Pt, PFN_TO_PTE(Pages[i]) | Attributes);
+#endif
+    }
+
+    return(STATUS_SUCCESS);
+}
+
+NTSTATUS
+NTAPI
+MmCreatePageFileMapping(PEPROCESS Process,
+                        PVOID Address,
+                        SWAPENTRY SwapEntry)
+{
+    if (Process == NULL && Address < MmSystemRangeStart)
+    {
+	DPRINT1("No process\n");
+	KEBUGCHECK(0);
+    }
+    if (Process != NULL && Address >= MmSystemRangeStart)
+    {
+	DPRINT1("Setting kernel address with process context\n");
+	KEBUGCHECK(0);
+    }
+    if (SwapEntry & (1 << 31))
+    {
+	KEBUGCHECK(0);
+    }
+
+    // XXX arty
+    
+    return(STATUS_SUCCESS);
+}
+
+
+NTSTATUS
+NTAPI
+MmCreateVirtualMappingUnsafe(PEPROCESS Process,
+                             PVOID Address,
+                             ULONG flProtect,
+                             PPFN_TYPE Pages,
+                             ULONG PageCount)
+{
+    ULONG Attributes;
+    PVOID Addr;
+    ULONG i;
+    ppc_map_info_t info;
+    
+    DPRINT("MmCreateVirtualMappingUnsafe(%x, %x, %x, %x (%x), %d)\n",
+	   Process, Address, flProtect, Pages, *Pages, PageCount);
+
+    if (Process == NULL)
+    {
+	if (Address < MmSystemRangeStart)
+	{
+	    DPRINT1("No process\n");
+	    KEBUGCHECK(0);
+	}
+	if (PageCount > 0x10000 ||
+	    (ULONG_PTR) Address / PAGE_SIZE + PageCount > 0x100000)
+	{
+	    DPRINT1("Page count to large\n");
+	    KEBUGCHECK(0);
+	}
+    }
+    else
+    {
+	if (Address >= MmSystemRangeStart)
+	{
+	    DPRINT1("Setting kernel address with process context\n");
+	    KEBUGCHECK(0);
+	}
+	if (PageCount > (ULONG_PTR)MmSystemRangeStart / PAGE_SIZE ||
+	    (ULONG_PTR) Address / PAGE_SIZE + PageCount >
+	    (ULONG_PTR)MmSystemRangeStart / PAGE_SIZE)
+	{
+	    DPRINT1("Page Count to large\n");
+	    KEBUGCHECK(0);
+	}
+    }
+    
+    Attributes = ProtectToFlags(flProtect);
+    Addr = Address;
+    
+    for (i = 0; i < PageCount; i++, Addr = (PVOID)((ULONG_PTR)Addr + PAGE_SIZE))
+    {
+	Process = PsGetCurrentProcess();
+	info.proc = Process ? (int)Process->UniqueProcessId : 0;
+	info.addr = (vaddr_t)Addr;
+	info.flags = Attributes;
+	MmuMapPage(&info, 1);
+	//(void)InterlockedExchangeUL(Pt, PFN_TO_PTE(Pages[i]) | Attributes);
+	if (Address < MmSystemRangeStart &&
+	    ((PMADDRESS_SPACE)&Process->VadRoot)->PageTableRefCountTable != NULL &&
+	    Attributes & PA_PRESENT)
+	{
+#if 0
+            PUSHORT Ptrc;
+	    
+            Ptrc = ((PMADDRESS_SPACE)&Process->VadRoot)->PageTableRefCountTable;
+	    
+            Ptrc[ADDR_TO_PAGE_TABLE(Addr)]++;
+#endif
+	}
+    }
+    return(STATUS_SUCCESS);
+}
+
+NTSTATUS
+NTAPI
+MmCreateVirtualMapping(PEPROCESS Process,
+                       PVOID Address,
+                       ULONG flProtect,
+                       PPFN_TYPE Pages,
+                       ULONG PageCount)
+{
+   ULONG i;
+
+   for (i = 0; i < PageCount; i++)
+   {
+      if (!MmIsUsablePage(Pages[i]))
+      {
+         DPRINT1("Page at address %x not usable\n", PFN_TO_PTE(Pages[i]));
+         KEBUGCHECK(0);
+      }
+   }
+
+   return(MmCreateVirtualMappingUnsafe(Process,
+                                       Address,
+                                       flProtect,
+                                       Pages,
+                                       PageCount));
+}
+
+ULONG
+NTAPI
+MmGetPageProtect(PEPROCESS Process, PVOID Address)
+{
+    ULONG Protect = 0;
+    ppc_map_info_t info = { 0 };
+
+    info.proc = Process ? (int)Process->UniqueProcessId : 0;
+    info.addr = (vaddr_t)Address;
+    MmuInqPage(&info, 1);
+    
+    if (!info.phys) { return PAGE_NOACCESS; }
+    if (!(info.flags & MMU_KMASK))
+    {
+	Protect |= PAGE_SYSTEM;
+	if ((info.flags & MMU_KR) && (info.flags & MMU_KW))
+	    Protect = PAGE_READWRITE;
+	else if (info.flags & MMU_KR)
+	    Protect = PAGE_EXECUTE_READ;
+    }
+    else
+    {
+	if ((info.flags & MMU_UR) && (info.flags & MMU_UW))
+	    Protect = PAGE_READWRITE;
+	else
+	    Protect = PAGE_EXECUTE_READ;
+    }
+    return(Protect);
+}
+
+VOID
+NTAPI
+MmSetPageProtect(PEPROCESS Process, PVOID Address, ULONG flProtect)
+{
+   //ULONG Attributes = 0;
+
+   DPRINT("MmSetPageProtect(Process %x  Address %x  flProtect %x)\n",
+          Process, Address, flProtect);
+
+#if 0
+   Attributes = ProtectToPTE(flProtect);
+
+   Pt = MmGetPageTableForProcess(Process, Address, FALSE);
+   if (Pt == NULL)
+   {
+       KEBUGCHECK(0);
+   }
+   InterlockedExchange((PLONG)Pt, PAGE_MASK(*Pt) | Attributes | (*Pt & (PA_ACCESSED|PA_DIRTY)));
+   MiFlushTlb(Pt, Address);
+#endif
+}
+
+PVOID
+NTAPI
+MmCreateHyperspaceMapping(PFN_TYPE Page)
+{
+    PVOID Address;
+    ppc_map_info_t info = { 0 };    
+
+    Address = (PVOID)((ULONG_PTR)HYPERSPACE * PAGE_SIZE);
+    info.proc = 0;
+    info.addr = (vaddr_t)Address;
+    info.flags = MMU_KRW;
+    MmuMapPage(&info, 1);
+
+    return Address;
+}
+
+PFN_TYPE
+NTAPI
+MmChangeHyperspaceMapping(PVOID Address, PFN_TYPE NewPage)
+{
+    PFN_TYPE OldPage;
+    ppc_map_info_t info = { 0 };
+
+    info.proc = 0;
+    info.addr = (vaddr_t)Address;
+    MmuUnmapPage(&info, 1);
+    OldPage = info.phys;
+    info.phys = (paddr_t)NewPage;
+    MmuMapPage(&info, 1);
+
+    return NewPage;
+}
+
+PFN_TYPE
+NTAPI
+MmDeleteHyperspaceMapping(PVOID Address)
+{
+    ppc_map_info_t info = { 0 };
+    ASSERT (IS_HYPERSPACE(Address));
+
+    info.proc = 0;
+    info.addr = (vaddr_t)Address;
+    
+    MmuUnmapPage(&info, 1);
+
+    return (PFN_TYPE)info.phys;
+}
+
+VOID
+INIT_FUNCTION
+NTAPI
+MmInitGlobalKernelPageDirectory(VOID)
+{
+}
+
+VOID
+INIT_FUNCTION
+NTAPI
+MiInitPageDirectoryMap(VOID)
+{
+}
+
+ULONG
+NTAPI
+MiGetUserPageDirectoryCount(VOID)
+{
+    return 0;
+}
+
+VOID
+NTAPI
+MmUpdatePageDir(PEPROCESS Process, PVOID Address, ULONG Size)
+{
+}
+
+/* EOF */
diff --git a/reactos/ntoskrnl/mm/powerpc/pfault.c b/reactos/ntoskrnl/mm/powerpc/pfault.c
new file mode 100644
index 00000000000..381f3ad0746
--- /dev/null
+++ b/reactos/ntoskrnl/mm/powerpc/pfault.c
@@ -0,0 +1,96 @@
+/* $Id: pfault.c 24443 2006-10-08 10:01:27Z arty $
+ *
+ * COPYRIGHT:       See COPYING in the top level directory
+ * PROJECT:         ReactOS kernel
+ * FILE:            ntoskrnl/mm/powerpc/pfault.c
+ * PURPOSE:         Paging file functions
+ *
+ * PROGRAMMERS:     David Welch (welch@mcmail.com)
+ */
+
+/* INCLUDES *****************************************************************/
+
+#include <ntoskrnl.h>
+#define NDEBUG
+#include <internal/debug.h>
+#include <ppcmmu/mmu.h>
+
+/* EXTERNS *******************************************************************/
+
+extern ULONG KiKernelTrapHandler(PKTRAP_FRAME Tf, ULONG ExceptionNr, PVOID Cr2);
+
+/* FUNCTIONS *****************************************************************/
+
+VOID MmpPpcTrapFrameToTrapFrame(ppc_trap_frame_t *frame, PKTRAP_FRAME Tf)
+{
+    RtlCopyMemory(&Tf->Gpr0, frame->gpr, 12 * sizeof(ULONG));
+    Tf->Lr = frame->lr;
+    Tf->Cr = frame->cr;
+    Tf->Ctr = frame->ctr;
+    Tf->Xer = frame->xer;
+    Tf->Msr = frame->srr1 & 0xffff;
+    Tf->Dr0 = frame->srr0;
+    Tf->Dr1 = frame->srr1;
+    Tf->Dr2 = frame->dar;
+    Tf->Dr3 = frame->dsisr;
+}
+
+int KiPageFaultHandler(int inst, ppc_trap_frame_t *frame)
+{
+    NTSTATUS Status = STATUS_SUCCESS;
+    KPROCESSOR_MODE Mode;
+    EXCEPTION_RECORD Er;
+    KTRAP_FRAME Tf;
+    BOOLEAN AccessFault = !!(frame->dsisr & (1<<28));
+    vaddr_t VirtualAddr;
+    PVOID TrapInfo = NULL;
+    
+    /* get the faulting address */
+    if (inst)
+	VirtualAddr = frame->srr0;
+    else
+	VirtualAddr = frame->dar;
+    
+    /* MSR_PR */
+    Mode = frame->srr1 & 0x4000 ? KernelMode : UserMode;
+    
+    /* handle the fault */
+    if (AccessFault)
+    {
+	Status = MmAccessFault(Mode, (PVOID)VirtualAddr, FALSE, TrapInfo);
+    }
+    else
+    {
+	KeBugCheck(0);
+	//Status = MmNotPresentFault(Mode, (PVOID)VirtualAddr, FALSE, TrapInfo);
+    }
+    
+    if (NT_SUCCESS(Status))
+	return 1;
+    
+    if (KeGetCurrentThread()->ApcState.UserApcPending)
+    {
+        KIRQL oldIrql;
+        
+        KeRaiseIrql(APC_LEVEL, &oldIrql);
+        KiDeliverApc(UserMode, NULL, NULL);
+        KeLowerIrql(oldIrql);
+    }
+    
+    MmpPpcTrapFrameToTrapFrame(frame, &Tf);
+    
+    Er.ExceptionCode = STATUS_ACCESS_VIOLATION;
+    Er.ExceptionFlags = 0;
+    Er.ExceptionRecord = NULL;
+    Er.ExceptionAddress = (PVOID)frame->srr0;
+    Er.NumberParameters = 2;
+    Er.ExceptionInformation[0] = AccessFault;
+    Er.ExceptionInformation[1] = VirtualAddr;
+    
+    /* FIXME: Which exceptions are noncontinuable? */
+    Er.ExceptionFlags = 0;
+    
+    KiDispatchException(&Er, 0, &Tf, Mode, TRUE);
+    return 1;
+}
+
diff --git a/reactos/ntoskrnl/ntoskrnl.rbuild b/reactos/ntoskrnl/ntoskrnl.rbuild
index 5431d9269b9..33ef8665556 100644
--- a/reactos/ntoskrnl/ntoskrnl.rbuild
+++ b/reactos/ntoskrnl/ntoskrnl.rbuild
@@ -18,6 +18,7 @@
 	<include base="ntoskrnl">include</include>
 	<include base="ntoskrnl" root="intermediate"></include>
 	<include base="ntoskrnl" root="intermediate">include</include>
+	<include base="ntoskrnl" root="intermediate">include/internal</include>
 	<include base="ReactOS">include/reactos/drivers</include>
 	<library>csq</library>
 	<library>hal</library>
@@ -29,6 +30,7 @@
 	<library>kdcom</library>
 	<library>bootvid</library>
 	<library>wdmguid</library>
+	<library>ppcmmu</library>
 	<directory name="include">
 		<pch>ntoskrnl.h</pch>
 	</directory>
@@ -54,6 +56,17 @@
 				<file>v86m_sup.S</file>
 			</directory>
 		</if>
+		<if property="ARCH" value="powerpc">
+			<directory name="powerpc">
+				<file first="true">main_asm.S</file>
+				<file>cpu.c</file>
+				<file>exp.c</file>
+				<file>kiinit.c</file>
+				<file>ppc_irq.c</file>
+				<file>stubs.c</file>
+				<file>systimer.c</file>
+			</directory>
+		</if>
 		<file>apc.c</file>
 		<file>balmgr.c</file>
 		<file>bug.c</file>
@@ -93,6 +106,11 @@
 				<file>cmhardwr.c</file>
 			</directory>
 		</if>
+		<if property="ARCH" value="powerpc">
+			<directory name="powerpc">
+				<file>cmhardwr.c</file>
+			</directory>
+		</if>
 		<file>cmapi.c</file>
 		<file>cmboot.c</file>
 		<file>cmcheck.c</file>
@@ -135,6 +153,12 @@
 				<file>ioport.S</file>
 			</directory>
 		</if>
+		<if property="ARCH" value="powerpc">
+			<directory name="powerpc">
+				<file>ioport.s</file>
+				<file>fastinterlck.c</file>
+			</directory>
+		</if>
 		<file>atom.c</file>
 		<file>callback.c</file>
 		<file>dbgctrl.c</file>
@@ -257,7 +281,12 @@
 		<directory name="kd">
 			<directory name="wrappers">
 				<file>bochs.c</file>
-				<file>gdbstub.c</file>
+				<if property="ARCH" value="i386">
+					<file>gdbstub.c</file>
+				</if>
+				<if property="ARCH" value="powerpc">
+					<file>gdbstub_powerpc.c</file>
+				</if>
 				<file>kdbg.c</file>
 			</directory>
 			<file>kdinit.c</file>
@@ -292,6 +321,12 @@
 				<file>page.c</file>
 			</directory>
 		</if>
+		<if property="ARCH" value="powerpc">
+			<directory name="powerpc">
+				<file>pfault.c</file>
+				<file>page.c</file>
+			</directory>
+		</if>
 		<file>anonmem.c</file>
 		<file>aspace.c</file>
 		<file>balance.c</file>
diff --git a/reactos/ntoskrnl/ntoskrnl.lnk b/reactos/ntoskrnl/ntoskrnl_i386.lnk
similarity index 100%
rename from reactos/ntoskrnl/ntoskrnl.lnk
rename to reactos/ntoskrnl/ntoskrnl_i386.lnk
diff --git a/reactos/ntoskrnl/ntoskrnl_powerpc.lnk b/reactos/ntoskrnl/ntoskrnl_powerpc.lnk
new file mode 100644
index 00000000000..c2cde72b897
--- /dev/null
+++ b/reactos/ntoskrnl/ntoskrnl_powerpc.lnk
@@ -0,0 +1,69 @@
+/* Default linker script, for normal executables */
+OUTPUT_FORMAT("elf32-powerpc", "elf32-powerpc",
+	      "elf32-powerpc")
+OUTPUT_ARCH(powerpc:common)
+SECTIONS
+{
+  .text :
+  {
+    __text_start__ = .;
+    *(.text)
+    *(init)
+    *(INIT)
+    __text_end__ = .;
+  }
+  .data :
+  {
+    *(.data)
+    *(.data2)
+    *(.rdata)
+    *(.sdata)
+    *(.pdata)
+  }
+  .rodata :
+  {
+    *(.rodata)
+    *(.got2)
+    *(.eh_frame)
+  }
+  .idata :
+  {
+     *(.idata$2)
+     SORT(*)(.idata$3)
+     LONG(0); LONG(0); LONG(0); LONG(0); LONG(0);
+     SORT(*)(.idata$4)
+     SORT(*)(.idata$5)
+     SORT(*)(.idata$6)
+     SORT(*)(.idata$7)
+  }
+  .edata :
+  {
+    *(.edata)
+  }
+  .bss :
+  {
+    *(.sbss)
+    *(.bss)
+    *(COMMON)
+  }  
+  .rsrc :
+  {
+    *(.rsrc)
+  }
+  .rela.text :
+  {
+    *(.rela.text)
+  }
+  .rela.data :
+  {
+    *(.rela.data)
+  }
+  .rela.rodata :
+  {
+    *(.rela.rodata)
+  }
+  .rela.got2 :
+  {
+    *(.rela.got2)
+  }
+}
diff --git a/reactos/ntoskrnl/ps/debug.c b/reactos/ntoskrnl/ps/debug.c
index 402fc22f821..6af913d9c0e 100644
--- a/reactos/ntoskrnl/ps/debug.c
+++ b/reactos/ntoskrnl/ps/debug.c
@@ -181,6 +181,7 @@ PsGetContextThread(IN PETHREAD Thread,
         /* Read the flags */
         Flags = ProbeForReadUlong(&ThreadContext->ContextFlags);
 
+#ifdef _M_IX86
         /* Check if the caller wanted extended registers */
         if ((Flags & CONTEXT_EXTENDED_REGISTERS) !=
             CONTEXT_EXTENDED_REGISTERS)
@@ -188,6 +189,7 @@ PsGetContextThread(IN PETHREAD Thread,
             /* Cut them out of the size */
             Size = FIELD_OFFSET(CONTEXT, ExtendedRegisters);
         }
+#endif
 
         /* Check if we came from user mode */
         if (PreviousMode != KernelMode)
@@ -299,6 +301,7 @@ PsSetContextThread(IN PETHREAD Thread,
         /* Read the flags */
         Flags = ProbeForReadUlong(&ThreadContext->ContextFlags);
 
+#ifdef _M_IX86
         /* Check if the caller wanted extended registers */
         if ((Flags & CONTEXT_EXTENDED_REGISTERS) !=
             CONTEXT_EXTENDED_REGISTERS)
@@ -306,6 +309,7 @@ PsSetContextThread(IN PETHREAD Thread,
             /* Cut them out of the size */
             Size = FIELD_OFFSET(CONTEXT, ExtendedRegisters);
         }
+#endif
 
         /* Check if we came from user mode */
         if (PreviousMode != KernelMode)
diff --git a/reactos/ntoskrnl/ps/thread.c b/reactos/ntoskrnl/ps/thread.c
index ebf09667ccf..ab8b5630b0d 100644
--- a/reactos/ntoskrnl/ps/thread.c
+++ b/reactos/ntoskrnl/ps/thread.c
@@ -324,7 +324,8 @@ PspCreateThread(OUT PHANDLE ThreadHandle,
         Thread->StartAddress = (PVOID)ThreadContext->Eip;
         Thread->Win32StartAddress = (PVOID)ThreadContext->Eax;
 #elif defined(_M_PPC)
-#error Not implemented yet for PPC architecture!
+	Thread->StartAddress = (PVOID)ThreadContext->Dr0;
+	Thread->Win32StartAddress = (PVOID)ThreadContext->Gpr3;
 #elif defined(_M_MIPS)
         for (;;);
 #else
diff --git a/reactos/ntoskrnl/rtl/libsupp.c b/reactos/ntoskrnl/rtl/libsupp.c
index 5a0eff2a041..9247ed5838e 100644
--- a/reactos/ntoskrnl/rtl/libsupp.c
+++ b/reactos/ntoskrnl/rtl/libsupp.c
@@ -325,7 +325,11 @@ RtlWalkFrameChain(OUT PVOID *Callers,
             /* Get the stack limits */
             StackBegin = (ULONG_PTR)Teb->Tib.StackLimit;
             StackEnd = (ULONG_PTR)Teb->Tib.StackBase;
+#ifdef _M_IX86
             Stack = TrapFrame->Ebp;
+#elif defined(_M_PPC)
+            Stack = TrapFrame->Gpr1;
+#endif
 
             /* Validate them */
             if (StackEnd <= StackBegin) return 0;
diff --git a/reactos/subsystems/win32/win32k/win32k.rbuild b/reactos/subsystems/win32/win32k/win32k.rbuild
index 7096ce4c137..61d0dce13f7 100644
--- a/reactos/subsystems/win32/win32k/win32k.rbuild
+++ b/reactos/subsystems/win32/win32k/win32k.rbuild
@@ -2,8 +2,9 @@
 <!DOCTYPE group SYSTEM "../../../tools/rbuild/project.dtd">
 <group>
 <module name="win32k_base" type="objectlibrary">
-	<include base="win32k">.</include>
-	<include base="win32k">include</include>
+	<include base="win32k_base">.</include>
+	<include base="win32k_base">include</include>
+	<include base="win32k_base" root="intermediate">.</include>
 	<include base="ntoskrnl">include</include>
 	<include base="freetype">include</include>
 	<include base="ReactOS">include/reactos/subsys</include>
diff --git a/reactos/tools/ppc.lost+found/bootcd b/reactos/tools/ppc.lost+found/bootcd
index e3e03adfbc9..d808ee4e70f 100755
--- a/reactos/tools/ppc.lost+found/bootcd
+++ b/reactos/tools/ppc.lost+found/bootcd
@@ -9,10 +9,8 @@ CD=output-ppc/ppcboot
 I=$CD/install
 TOOLS=tools/ppc.lost+found
 
-$TOOLS/link-freeldr
-
 mkdir -p $I
-cp freeldr.elf $I/yaboot
+cp output-ppc/boot/freeldr/freeldr/ofwldr $I/yaboot
 cp `dirname $0`/ofboot.b $I
 
 mkisofs -chrp-boot -U -part -hfs -T -r -l -J -A "ReactOS" -sysid PPC \
diff --git a/reactos/tools/ppc.lost+found/link-freeldr b/reactos/tools/ppc.lost+found/link-freeldr
deleted file mode 100755
index 125f22f3acf..00000000000
--- a/reactos/tools/ppc.lost+found/link-freeldr
+++ /dev/null
@@ -1,7 +0,0 @@
-#!/bin/sh -v
-
-export PATH=$PATH:/usr/local/pkg/reactos-powerpc/bin
-powerpc-unknown-linux-gnu-ld \
-	-g -nostartfiles -nostdlib -N -Ttext=0xe00000 \
-	-o freeldr.elf output-ppc/boot/freeldr/freeldr/ofwldr \
-	-Lobj-ppc/lib/ppcmmu -lppcmmu_code -lppcmmu
diff --git a/reactos/tools/ppc.lost+found/pmake b/reactos/tools/ppc.lost+found/pmake
deleted file mode 100755
index 988f524e55c..00000000000
--- a/reactos/tools/ppc.lost+found/pmake
+++ /dev/null
@@ -1,14 +0,0 @@
-#!/bin/sh
-
-export PATH=$PATH:/usr/local/pkg/reactos-powerpc/bin
-make \
-	ARCH=powerpc \
-	HOST=mingw32-linux \
-	PREFIX=reactos-powerpc \
-	ROS_INTERMEDIATE=obj-ppc \
-	ROS_OUTPUT=output-ppc \
-	ROS_PREFIX=reactos-powerpc \
-	ROS_INSTALL=rosppc \
-	ROS_AUTOMAKE=makefile.ppc \
-	ROS_RBUILDFLAGS=-rReactOS-ppc.rbuild \
-	$*
diff --git a/reactos/tools/rbuild/backend/mingw/mingw.cpp b/reactos/tools/rbuild/backend/mingw/mingw.cpp
index 9e7bd06c2a7..fcf4cffda2e 100644
--- a/reactos/tools/rbuild/backend/mingw/mingw.cpp
+++ b/reactos/tools/rbuild/backend/mingw/mingw.cpp
@@ -373,8 +373,9 @@ MingwBackend::GenerateHeader () const
 string
 MingwBackend::GenerateIncludesAndDefines ( IfableData& data ) const
 {
+	set<string> used_defs;
 	string includeParameters = MingwModuleHandler::GenerateGccIncludeParametersFromVector ( data.includes );
-	string defineParameters = MingwModuleHandler::GenerateGccDefineParametersFromVector ( data.defines );
+	string defineParameters = MingwModuleHandler::GenerateGccDefineParametersFromVector ( data.defines, used_defs );
 	return includeParameters + " " + defineParameters;
 }
 
diff --git a/reactos/tools/rbuild/backend/mingw/modulehandler.cpp b/reactos/tools/rbuild/backend/mingw/modulehandler.cpp
index 1fa82bb3015..30909d5740c 100644
--- a/reactos/tools/rbuild/backend/mingw/modulehandler.cpp
+++ b/reactos/tools/rbuild/backend/mingw/modulehandler.cpp
@@ -22,6 +22,7 @@
 #include "mingw.h"
 #include "modulehandler.h"
 
+using std::set;
 using std::string;
 using std::vector;
 
@@ -627,14 +628,20 @@ MingwModuleHandler::GetObjectFilenames ()
 
 /* static */ string
 MingwModuleHandler::GenerateGccDefineParametersFromVector (
-	const vector<Define*>& defines )
+	const vector<Define*>& defines,
+        set<string>& used_defs)
 {
 	string parameters;
+
 	for ( size_t i = 0; i < defines.size (); i++ )
 	{
 		Define& define = *defines[i];
+		if (used_defs.find(define.name) != used_defs.end())
+			continue;
 		if (parameters.length () > 0)
 			parameters += " ";
+                if (define.name.find('(') != string::npos)
+                        parameters += "$(QT)";
 		parameters += "-D";
 		parameters += define.name;
 		if (define.value.length () > 0)
@@ -642,6 +649,9 @@ MingwModuleHandler::GenerateGccDefineParametersFromVector (
 			parameters += "=";
 			parameters += define.value;
 		}
+                if (define.name.find('(') != string::npos)
+                        parameters += "$(QT)";
+		used_defs.insert(used_defs.begin(),define.name);
 	}
 	return parameters;
 }
@@ -649,8 +659,9 @@ MingwModuleHandler::GenerateGccDefineParametersFromVector (
 string
 MingwModuleHandler::GenerateGccDefineParameters () const
 {
-	string parameters = GenerateGccDefineParametersFromVector ( module.project.non_if_data.defines );
-	string s = GenerateGccDefineParametersFromVector ( module.non_if_data.defines );
+        set<string> used_defs;
+	string parameters = GenerateGccDefineParametersFromVector ( module.project.non_if_data.defines, used_defs );
+	string s = GenerateGccDefineParametersFromVector ( module.non_if_data.defines, used_defs );
 	if ( s.length () > 0 )
 	{
 		parameters += " ";
@@ -2458,17 +2469,17 @@ MingwKernelModuleHandler::GenerateKernelModuleTarget ()
 
 		string dependencies = linkDepsMacro + " " + objectsMacro;
 
-		string linkerParameters = ssprintf ( "-Wl,-T,%s%cntoskrnl.lnk -Wl,--subsystem,native -Wl,--entry,%s -Wl,--image-base,%s -Wl,--file-alignment,0x1000 -Wl,--section-alignment,0x1000 -nostartfiles -shared",
+		string linkerParameters = ssprintf ( "-Wl,-T,%s%cntoskrnl_$(ARCH).lnk -Wl,--subsystem,native -Wl,--entry,%s -Wl,--image-base,%s",
 		                                     module.output->relative_path.c_str (),
 		                                     cSep,
 		                                     module.GetEntryPoint(true).c_str (),
 		                                     module.baseaddress.c_str () );
 		GenerateLinkerCommand ( dependencies,
-		                        "${gcc}",
-		                        linkerParameters,
-		                        objectsMacro,
-		                        libsMacro,
-		                        "-sections" );
+					"${gcc}",
+					linkerParameters + " $(NTOSKRNL_SHARED)",
+					objectsMacro,
+					libsMacro,
+					"-sections" );
 	}
 	else
 	{
@@ -3708,7 +3719,7 @@ MingwElfExecutableModuleHandler::Process ()
 
 	fprintf ( fMakefile, "\t$(ECHO_BOOTPROG)\n" );
 
-	fprintf ( fMakefile, "\t${ld} $(%s_LINKFORMAT) %s %s -g -o %s\n",
+	fprintf ( fMakefile, "\t${gcc} $(%s_LINKFORMAT) %s %s -g -o %s\n",
 	          module.buildtype.c_str(),
 	          objectsMacro.c_str(),
 	          libsMacro.c_str(),
diff --git a/reactos/tools/rbuild/backend/mingw/modulehandler.h b/reactos/tools/rbuild/backend/mingw/modulehandler.h
index d45d8bbb688..ba5d0a21eb6 100644
--- a/reactos/tools/rbuild/backend/mingw/modulehandler.h
+++ b/reactos/tools/rbuild/backend/mingw/modulehandler.h
@@ -51,7 +51,7 @@ public:
 		const Module& module,
 		string_list* pclean_files );
 
-	static std::string GenerateGccDefineParametersFromVector ( const std::vector<Define*>& defines );
+	static std::string GenerateGccDefineParametersFromVector ( const std::vector<Define*>& defines, std::set<std::string> &used_defs );
 	static std::string GenerateGccIncludeParametersFromVector ( const std::vector<Include*>& includes );
 
 	std::string GetModuleTargets ( const Module& module );
diff --git a/reactos/tools/tools.mak b/reactos/tools/tools.mak
index 62653a7ae91..5927f0d5288 100644
--- a/reactos/tools/tools.mak
+++ b/reactos/tools/tools.mak
@@ -50,7 +50,9 @@ include tools/buildno/buildno.mak
 include tools/cabman/cabman.mak
 include tools/cdmake/cdmake.mak
 include tools/gendib/gendib.mak
+ifeq ($(ARCH),powerpc)
 include tools/ofw_interface/ofw_interface.mak
+endif
 include tools/mkhive/mkhive.mak
 include tools/nci/nci.mak
 include tools/pefixup.mak
@@ -64,4 +66,4 @@ include tools/wpp/wpp.mak
 include tools/widl/widl.mak
 include tools/winebuild/winebuild.mak
 include tools/wmc/wmc.mak
-include tools/wrc/wrc.mak
\ No newline at end of file
+include tools/wrc/wrc.mak