diff --git a/bochs/bochs.h b/bochs/bochs.h
index 4f0a9b165..48da8b143 100644
--- a/bochs/bochs.h
+++ b/bochs/bochs.h
@@ -1,5 +1,5 @@
 /////////////////////////////////////////////////////////////////////////
-// $Id: bochs.h,v 1.83 2002-08-31 04:57:18 bdenney Exp $
+// $Id: bochs.h,v 1.84 2002-08-31 12:24:39 vruppert Exp $
 /////////////////////////////////////////////////////////////////////////
 //
 //  Copyright (C) 2002  MandrakeSoft S.A.
@@ -153,11 +153,9 @@ extern "C" {
   BX_MEM(0)->read_physical(BX_CPU(0), phy_addr, len, ptr)
 #define BX_MEM_WRITE_PHYSICAL(addr, len, ptr) \
   BX_MEM(0)->write_physical(BX_CPU(0), phy_addr, len, ptr)
-// macros for PCI handling
+// macro for PCI handling
 #define BX_REGISTER_PCI_HANDLERS(this_ptr, pci_read, pci_write, devfunc, name) \
   bx_pci.register_pci_handlers(this_ptr, pci_read, pci_write, devfunc, name)
-#define BX_PCI_LOAD_ROM(fd, offset, size) bx_pci.load_ROM(fd, offset, size)
-#define BX_PCI_MEM_READ(offset) bx_pci.mem_read(offset)
 
 #if BX_SMP_PROCESSORS==1
 #define BX_CPU(x)                   (&bx_cpu)
diff --git a/bochs/cpu/cpu.cc b/bochs/cpu/cpu.cc
index afb574012..eae34d1ff 100644
--- a/bochs/cpu/cpu.cc
+++ b/bochs/cpu/cpu.cc
@@ -1,5 +1,5 @@
 /////////////////////////////////////////////////////////////////////////
-// $Id: cpu.cc,v 1.32 2002-06-06 23:03:09 yakovlev Exp $
+// $Id: cpu.cc,v 1.33 2002-08-31 12:24:39 vruppert Exp $
 /////////////////////////////////////////////////////////////////////////
 //
 //  Copyright (C) 2001  MandrakeSoft S.A.
@@ -740,7 +740,7 @@ BX_CPU_C::prefetch(void)
 #if BX_PCI_SUPPORT
   if ((new_phy_addr >= 0x000C0000) && (new_phy_addr <= 0x000FFFFF)) {
     BX_CPU_THIS_PTR bytesleft = 0x4000 - (new_phy_addr & 0x3FFF);
-    BX_CPU_THIS_PTR fetch_ptr = bx_devices.pci->i440fx_fetch_ptr(new_phy_addr);
+    BX_CPU_THIS_PTR fetch_ptr = BX_CPU_THIS_PTR mem->pci_fetch_ptr(new_phy_addr);
   } else {
     BX_CPU_THIS_PTR bytesleft = (BX_CPU_THIS_PTR max_phy_addr - new_phy_addr) + 1;
     BX_CPU_THIS_PTR fetch_ptr = &BX_CPU_THIS_PTR mem->vector[new_phy_addr];
@@ -773,7 +773,7 @@ BX_CPU_C::revalidate_prefetch_q(void)
 #if BX_PCI_SUPPORT
     if ((new_phy_addr >= 0x000C0000) && (new_phy_addr <= 0x000FFFFF)) {
       BX_CPU_THIS_PTR bytesleft = 0x4000 - (new_phy_addr & 0x3FFF);
-      BX_CPU_THIS_PTR fetch_ptr = bx_devices.pci->i440fx_fetch_ptr(new_phy_addr);
+      BX_CPU_THIS_PTR fetch_ptr = BX_CPU_THIS_PTR mem->pci_fetch_ptr(new_phy_addr);
       }
     else {
       BX_CPU_THIS_PTR bytesleft = (BX_CPU_THIS_PTR max_phy_addr - new_phy_addr) + 1;
diff --git a/bochs/iodev/pci.cc b/bochs/iodev/pci.cc
index 12104333b..f2df44210 100644
--- a/bochs/iodev/pci.cc
+++ b/bochs/iodev/pci.cc
@@ -1,5 +1,5 @@
 /////////////////////////////////////////////////////////////////////////
-// $Id: pci.cc,v 1.18 2002-08-27 19:54:46 bdenney Exp $
+// $Id: pci.cc,v 1.19 2002-08-31 12:24:39 vruppert Exp $
 /////////////////////////////////////////////////////////////////////////
 //
 //  Copyright (C) 2002  MandrakeSoft S.A.
@@ -61,10 +61,6 @@ bx_pci_c::bx_pci_c(void)
   for (i=0; i < 0x100; i++) {
     BX_PCI_THIS pci_handler_id[i] = BX_MAX_PCI_DEVICES;  // not assigned
   }
-
-  for (i=0; i<0x40000; i++) {
-    BX_PCI_THIS s.i440fx.shadow[i] = 0xff;
-  }
 }
 
 bx_pci_c::~bx_pci_c(void)
@@ -472,37 +468,6 @@ bx_pci_c::print_i440fx_state()
 #endif /* DUMP_FULL_I440FX */
 }
 
-  Bit8u*
-bx_pci_c::i440fx_fetch_ptr(Bit32u addr)
-{
-  if (bx_options.Oi440FXSupport->get ()) {
-    switch (rd_memType (addr)) {
-      case 0x0:   // Read from ShadowRAM
-        return (&BX_PCI_THIS devices->mem->vector[addr]);
-
-      case 0x1:   // Read from ROM
-        return (&BX_PCI_THIS s.i440fx.shadow[(addr - 0xc0000)]);
-      default:
-        BX_PANIC(("i440fx_fetch_ptr(): default case"));
-        return(0);
-      }
-    }
-  else
-    return (&BX_PCI_THIS devices->mem->vector[addr]);
-}
-
-int
-bx_pci_c::load_ROM(int fd, Bit32u offset, Bit32u size)
-{
-  return read(fd, (bx_ptr_t) &bx_pci.s.i440fx.shadow[offset], size);
-}
-
-  Bit8u
-bx_pci_c::mem_read(Bit32u offset)
-{
-  return (BX_PCI_THIS s.i440fx.shadow[offset]);
-}
-
   Boolean
 bx_pci_c::register_pci_handlers( void *this_ptr, bx_pci_read_handler_t f1,
                                  bx_pci_write_handler_t f2, Bit8u devfunc,
diff --git a/bochs/iodev/pci.h b/bochs/iodev/pci.h
index 8cf82f051..8361c591d 100644
--- a/bochs/iodev/pci.h
+++ b/bochs/iodev/pci.h
@@ -1,5 +1,5 @@
 /////////////////////////////////////////////////////////////////////////
-// $Id: pci.h,v 1.8 2002-08-27 19:54:46 bdenney Exp $
+// $Id: pci.h,v 1.9 2002-08-31 12:24:41 vruppert Exp $
 /////////////////////////////////////////////////////////////////////////
 //
 //  Copyright (C) 2002  MandrakeSoft S.A.
@@ -45,7 +45,6 @@ typedef struct {
   Bit32u confAddr;
   Bit32u confData;
   Bit8u  pci_conf[256];
-  Bit8u  shadow[4*16*4096];     // 256k of memory
   } bx_def440fx_t;
 
 
@@ -63,9 +62,6 @@ public:
   BX_PCI_SMF void   print_i440fx_state( );
   BX_PCI_SMF Bit32u rd_memType (Bit32u addr);
   BX_PCI_SMF Bit32u wr_memType (Bit32u addr);
-  BX_PCI_SMF Bit8u* i440fx_fetch_ptr(Bit32u addr);
-  BX_PCI_SMF int    load_ROM(int fd, Bit32u offset, Bit32u size);
-  BX_PCI_SMF Bit8u  mem_read(Bit32u offset);
 
 private:
   bx_devices_c *devices;
diff --git a/bochs/memory/memory.cc b/bochs/memory/memory.cc
index ab454bcf7..73615d69a 100644
--- a/bochs/memory/memory.cc
+++ b/bochs/memory/memory.cc
@@ -1,5 +1,5 @@
 /////////////////////////////////////////////////////////////////////////
-// $Id: memory.cc,v 1.16 2002-08-17 09:23:42 vruppert Exp $
+// $Id: memory.cc,v 1.17 2002-08-31 12:24:41 vruppert Exp $
 /////////////////////////////////////////////////////////////////////////
 //
 //  Copyright (C) 2001  MandrakeSoft S.A.
@@ -239,7 +239,7 @@ inc_one:
       switch (bx_devices.pci->wr_memType(a20addr & 0xFC000)) {
         case 0x0:   // Writes to ShadowRAM
 //        BX_INFO(("Writing to ShadowRAM %08x, len %u ! ", (unsigned) a20addr, (unsigned) len));
-          vector[a20addr] = *data_ptr;
+          shadow[a20addr - 0xc0000] = *data_ptr;
           BX_DBG_DIRTY_PAGE(a20addr >> 12);
           BX_DYN_DIRTY_PAGE(a20addr >> 12);
           goto inc_one;
@@ -472,12 +472,12 @@ inc_one:
     else {
       switch (bx_devices.pci->rd_memType(a20addr & 0xFC000)) {
         case 0x0:   // Read from ShadowRAM
-          *data_ptr = vector[a20addr];
+          *data_ptr = shadow[a20addr - 0xc0000];
           BX_INFO(("Reading from ShadowRAM %08x, Data %02x ", (unsigned) a20addr, *data_ptr));
           goto inc_one;
 
         case 0x1:   // Read from ROM
-          *data_ptr = BX_PCI_MEM_READ(a20addr - 0xc0000);
+          *data_ptr = vector[a20addr];
           //BX_INFO(("Reading from ROM %08x, Data %02x  ", (unsigned) a20addr, *data_ptr));
           goto inc_one;
         default:
@@ -557,7 +557,7 @@ inc_one:
                 break;
 
               case 0x1:   // Read from Shadow RAM
-                *data_ptr = BX_PCI_MEM_READ(a20addr - 0xc0000);
+                *data_ptr = shadow[a20addr - 0xc0000];
                 BX_INFO(("Reading from ShadowRAM %08x, Data %02x  ", (unsigned) a20addr, *data_ptr));
                 break;
               default:
diff --git a/bochs/memory/memory.h b/bochs/memory/memory.h
index 105d25b54..9657ffbbb 100644
--- a/bochs/memory/memory.h
+++ b/bochs/memory/memory.h
@@ -1,5 +1,5 @@
 /////////////////////////////////////////////////////////////////////////
-// $Id: memory.h,v 1.6 2001-10-03 13:10:38 bdenney Exp $
+// $Id: memory.h,v 1.7 2002-08-31 12:24:41 vruppert Exp $
 /////////////////////////////////////////////////////////////////////////
 //
 //  Copyright (C) 2001  MandrakeSoft S.A.
@@ -45,6 +45,9 @@ public:
   Bit8u   *vector;
   size_t  len;
   size_t  megabytes;  // (len in Megabytes)
+#if BX_PCI_SUPPORT
+  Bit8u   shadow[4*16*4096]; // 256k of memory
+#endif
 #if BX_DEBUGGER
   unsigned char dbg_dirty_pages[(BX_MAX_DIRTY_PAGE_TABLE_MEGS * 1024 * 1024) / 4096];
   Bit32u dbg_count_dirty_pages () {
@@ -60,6 +63,9 @@ public:
   BX_MEM_SMF void    write_physical(BX_CPU_C *cpu, Bit32u addr, unsigned len, void *data);
   BX_MEM_SMF void    load_ROM(const char *path, Bit32u romaddress);
   BX_MEM_SMF Bit32u  get_memory_in_k(void);
+#if BX_PCI_SUPPORT
+  BX_MEM_SMF Bit8u*  pci_fetch_ptr(Bit32u addr);
+#endif
   BX_MEM_SMF Boolean dbg_fetch_mem(Bit32u addr, unsigned len, Bit8u *buf);
   BX_MEM_SMF Boolean dbg_set_mem(Bit32u addr, unsigned len, Bit8u *buf);
   BX_MEM_SMF Boolean dbg_crc32(
diff --git a/bochs/memory/misc_mem.cc b/bochs/memory/misc_mem.cc
index 2a092a3a0..de3ad0536 100644
--- a/bochs/memory/misc_mem.cc
+++ b/bochs/memory/misc_mem.cc
@@ -1,5 +1,5 @@
 /////////////////////////////////////////////////////////////////////////
-// $Id: misc_mem.cc,v 1.23 2002-08-18 08:53:26 vruppert Exp $
+// $Id: misc_mem.cc,v 1.24 2002-08-31 12:24:41 vruppert Exp $
 /////////////////////////////////////////////////////////////////////////
 //
 //  Copyright (C) 2002  MandrakeSoft S.A.
@@ -90,7 +90,7 @@ BX_MEM_C::~BX_MEM_C(void)
   void
 BX_MEM_C::init_memory(int memsize)
 {
-	BX_DEBUG(("Init $Id: misc_mem.cc,v 1.23 2002-08-18 08:53:26 vruppert Exp $"));
+	BX_DEBUG(("Init $Id: misc_mem.cc,v 1.24 2002-08-31 12:24:41 vruppert Exp $"));
   // you can pass 0 if memory has been allocated already through
   // the constructor, or the desired size of memory if it hasn't
 
@@ -107,6 +107,11 @@ BX_MEM_C::init_memory(int memsize)
   // initialize ROM area (0xc0000 .. 0xfffff) to 0xff
   memset(BX_MEM_THIS vector + 0xc0000, 0xff, 0x40000);
 
+#if BX_PCI_SUPPORT
+  // initialize PCI shadow RAM area (0xc0000 .. 0xfffff) to 0x00
+  memset(BX_MEM_THIS shadow, 0x00, 0x40000);
+#endif
+
 #if BX_DEBUGGER
   // initialize dirty pages table
   memset(dbg_dirty_pages, 0, sizeof(dbg_dirty_pages));
@@ -156,14 +161,7 @@ BX_MEM_C::load_ROM(const char *path, Bit32u romaddress)
 
   offset = 0;
   while (size > 0) {
-#if BX_PCI_SUPPORT
-    if (bx_options.Oi440FXSupport->get ())
-      ret = BX_PCI_LOAD_ROM(fd, (romaddress - 0xC0000 + offset), size);
-    else
-      ret = read(fd, (bx_ptr_t) &BX_MEM_THIS vector[romaddress + offset], size);
-#else
     ret = read(fd, (bx_ptr_t) &BX_MEM_THIS vector[romaddress + offset], size);
-#endif
     if (ret <= 0) {
       BX_PANIC(( "ROM: read failed on BIOS image: '%s'",path));
       }
@@ -171,29 +169,35 @@ BX_MEM_C::load_ROM(const char *path, Bit32u romaddress)
     offset += ret;
     }
   close(fd);
-#if BX_PCI_SUPPORT
-  if (bx_options.Oi440FXSupport->get ())
-    BX_INFO(("rom in i440FX RAM 0x%06x/%u ('%s')",
-			(unsigned) romaddress,
-			(unsigned) stat_buf.st_size,
-			path
-		));
-  else
-    BX_INFO(("rom at 0x%05x/%u ('%s')",
-			(unsigned) romaddress,
-			(unsigned) stat_buf.st_size,
-			path
-		));
-#else  // #if BX_PCI_SUPPORT
   BX_INFO(("rom at 0x%05x/%u ('%s')",
 			(unsigned) romaddress,
 			(unsigned) stat_buf.st_size,
  			path
 		));
-#endif // #if BX_PCI_SUPPORT
 }
 #endif // #if BX_PROVIDE_CPU_MEMORY
 
+#if BX_PCI_SUPPORT
+  Bit8u*
+BX_MEM_C::pci_fetch_ptr(Bit32u addr)
+{
+  if (bx_options.Oi440FXSupport->get ()) {
+    switch (bx_devices.pci->rd_memType (addr)) {
+      case 0x0:   // Read from ShadowRAM
+        return (&BX_MEM_THIS shadow[addr - 0xc0000]);
+
+      case 0x1:   // Read from ROM
+        return (&BX_MEM_THIS vector[addr]);
+      default:
+        BX_PANIC(("pci_fetch_ptr(): default case"));
+        return(0);
+      }
+    }
+  else
+    return (&BX_MEM_THIS vector[addr]);
+}
+#endif
+
 
 #if ( BX_DEBUGGER || BX_DISASM )
   Boolean
@@ -218,12 +222,12 @@ BX_MEM_C::dbg_fetch_mem(Bit32u addr, unsigned len, Bit8u *buf)
           ((addr >= 0x000C0000) && (addr <= 0x000FFFFF)) ) {
         switch (bx_devices.pci->rd_memType (addr)) {
           case 0x0:  // Fetch from ShadowRAM
-            *buf = vector[addr];
+            *buf = shadow[addr - 0xc0000];
 //          BX_INFO(("Fetching from ShadowRAM %06x, len %u !", (unsigned)addr, (unsigned)len));
             break;
 
           case 0x1:  // Fetch from ROM
-            *buf = BX_PCI_MEM_READ(addr - 0xC0000);
+            *buf = vector[addr];
 //          BX_INFO(("Fetching from ROM %06x, Data %02x ", (unsigned)addr, *buf));
             break;
           default: