Remove all of the Tru64 specific stuff from the base System object

into its own Tru64System object.  Also remove the System builder
stuff and create a Tru64System builder.  This makes it much
simpler to support more operating systems.

arch/alpha/ev5.cc:
    Each system provides its own mechanism for doing a breakpoint.
base/remote_gdb.hh:
    #include <map>
cpu/pc_event.cc:
cpu/pc_event.hh:
    Separate out System specific PCEvents
cpu/simple_cpu/simple_cpu.cc:
    each system provides its own init script
kern/tru64/dump_mbuf.cc:
kern/tru64/printf.cc:
    Stick this in a namespace

--HG--
extra : convert_revision : 9f74527ed2ff8010431d9aff34357aaecc1fb3f6

15 files changed, 627 insertions, 353 deletions

diff --git a/arch/alpha/ev5.cc b/arch/alpha/ev5.cc
index 476a84d26..e4a9a09e3 100644
--- a/arch/alpha/ev5.cc
+++ b/arch/alpha/ev5.cc
@@ -560,7 +560,7 @@ ExecContext::simPalCheck(int palFunc)
 
       case PAL::bpt:
       case PAL::bugchk:
-        if (system->remoteGDB->trap(ALPHA_KENTRY_IF))
+        if (system->breakpoint())
             return false;
         break;
     }
diff --git a/base/remote_gdb.hh b/base/remote_gdb.hh
index ba827c382..d8e09909a 100644
--- a/base/remote_gdb.hh
+++ b/base/remote_gdb.hh
@@ -29,6 +29,8 @@
 #ifndef __REMOTE_GDB_HH__
 #define __REMOTE_GDB_HH__
 
+#include <map>
+
 #include "base/kgdb.h"
 #include "cpu/pc_event.hh"
 #include "base/pollevent.hh"
diff --git a/cpu/pc_event.cc b/cpu/pc_event.cc
index 8c584a492..4ee93e864 100644
--- a/cpu/pc_event.cc
+++ b/cpu/pc_event.cc
@@ -37,15 +37,6 @@
 #include "base/trace.hh"
 #include "sim/universe.hh"
 
-#ifdef FULL_SYSTEM
-#include "targetarch/arguments.hh"
-#include "targetarch/pmap.h"
-#include "mem/functional_mem/memory_control.hh"
-#include "cpu/full_cpu/cpu.hh"
-#include "sim/system.hh"
-#include "cpu/full_cpu/bpred.hh"
-#endif
-
 using namespace std;
 
 PCEventQueue::PCEventQueue()
@@ -124,80 +115,6 @@ PCEventQueue::equal_range(Addr pc)
     return std::equal_range(pc_map.begin(), pc_map.end(), pc, MapCompare());
 }
 
-#ifdef FULL_SYSTEM
-void
-SkipFuncEvent::process(ExecContext *xc)
-{
-    Addr newpc = xc->regs.intRegFile[ReturnAddressReg];
-
-    DPRINTF(PCEvent, "skipping %s: pc=%x, newpc=%x\n", description,
-            xc->regs.pc, newpc);
-
-    xc->regs.pc = newpc;
-    xc->regs.npc = xc->regs.pc + sizeof(MachInst);
-
-    BranchPred *bp = xc->cpu->getBranchPred();
-    if (bp != NULL) {
-        bp->popRAS(xc->thread_num);
-    }
-}
-
-void
-BadAddrEvent::process(ExecContext *xc)
-{
-    // The following gross hack is the equivalent function to the
-    // annotation for vmunix::badaddr in:
-    // simos/simulation/apps/tcl/osf/tlaser.tcl
-
-    uint64_t a0 = xc->regs.intRegFile[ArgumentReg0];
-
-    if (a0 < ALPHA_K0SEG_BASE || a0 >= ALPHA_K1SEG_BASE ||
-        xc->memCtrl->badaddr(ALPHA_K0SEG_TO_PHYS(a0) & PA_IMPL_MASK)) {
-
-        DPRINTF(BADADDR, "badaddr arg=%#x bad\n", a0);
-        xc->regs.intRegFile[ReturnValueReg] = 0x1;
-        SkipFuncEvent::process(xc);
-    }
-    else
-        DPRINTF(BADADDR, "badaddr arg=%#x good\n", a0);
-}
-
-void Printf(AlphaArguments args);
-void DumpMbuf(AlphaArguments args);
-
-void
-PrintfEvent::process(ExecContext *xc)
-{
-    if (DTRACE(Printf)) {
-        DebugOut() << curTick << ": " << xc->cpu->name() << ": ";
-
-        AlphaArguments args(xc);
-        Printf(args);
-    }
-}
-
-void
-DebugPrintfEvent::process(ExecContext *xc)
-{
-    if (DTRACE(DebugPrintf)) {
-        if (!raw)
-            DebugOut() << curTick << ": " << xc->cpu->name() << ": ";
-
-        AlphaArguments args(xc);
-        Printf(args);
-    }
-}
-
-void
-DumpMbufEvent::process(ExecContext *xc)
-{
-    if (DTRACE(DebugPrintf)) {
-        AlphaArguments args(xc);
-        DumpMbuf(args);
-    }
-}
-#endif
-
 BreakPCEvent::BreakPCEvent(PCEventQueue *q, const std::string &desc, bool del)
     : PCEvent(q, desc), remove(del)
 {
diff --git a/cpu/pc_event.hh b/cpu/pc_event.hh
index d452bc030..645138fdd 100644
--- a/cpu/pc_event.hh
+++ b/cpu/pc_event.hh
@@ -163,52 +163,6 @@ PCEvent::schedule(PCEventQueue *q, Addr pc)
     return schedule();
 }
 
-
-#ifdef FULL_SYSTEM
-class SkipFuncEvent : public PCEvent
-{
-  public:
-    SkipFuncEvent(PCEventQueue *q, const std::string &desc)
-        : PCEvent(q, desc) {}
-    virtual void process(ExecContext *xc);
-};
-
-class BadAddrEvent : public SkipFuncEvent
-{
-  public:
-    BadAddrEvent(PCEventQueue *q, const std::string &desc)
-        : SkipFuncEvent(q, desc) {}
-    virtual void process(ExecContext *xc);
-};
-
-class PrintfEvent : public PCEvent
-{
-  public:
-    PrintfEvent(PCEventQueue *q, const std::string &desc)
-        : PCEvent(q, desc) {}
-    virtual void process(ExecContext *xc);
-};
-
-class DebugPrintfEvent : public PCEvent
-{
-  private:
-    bool raw;
-
-  public:
-    DebugPrintfEvent(PCEventQueue *q, const std::string &desc, bool r = false)
-        : PCEvent(q, desc), raw(r) {}
-    virtual void process(ExecContext *xc);
-};
-
-class DumpMbufEvent : public PCEvent
-{
-  public:
-    DumpMbufEvent(PCEventQueue *q, const std::string &desc)
-        : PCEvent(q, desc) {}
-    virtual void process(ExecContext *xc);
-};
-#endif
-
 class BreakPCEvent : public PCEvent
 {
   protected:
@@ -219,5 +173,4 @@ class BreakPCEvent : public PCEvent
     virtual void process(ExecContext *xc);
 };
 
-
 #endif // __PC_EVENT_HH__
diff --git a/cpu/simple_cpu/simple_cpu.cc b/cpu/simple_cpu/simple_cpu.cc
index 2bbd74efa..8da4b1641 100644
--- a/cpu/simple_cpu/simple_cpu.cc
+++ b/cpu/simple_cpu/simple_cpu.cc
@@ -150,7 +150,7 @@ SimpleCPU::SimpleCPU(const string &_name, Process *_process,
        _status = Idle;
     }
     else {
-      system->initBootContext(xc);
+      system->init(xc);
 
       // Reset the system
       //
diff --git a/kern/tru64/dump_mbuf.cc b/kern/tru64/dump_mbuf.cc
index 987412d95..b8ab7fa7c 100644
--- a/kern/tru64/dump_mbuf.cc
+++ b/kern/tru64/dump_mbuf.cc
@@ -37,6 +37,8 @@
 #include "targetarch/isa_traits.hh"
 #include "targetarch/vtophys.hh"
 
+namespace Tru64 {
+
 void
 DumpMbuf(AlphaArguments args)
 {
@@ -66,3 +68,5 @@ DumpMbuf(AlphaArguments args)
         CopyData(xc, &m, m.m_next, sizeof(m));
     }
 }
+
+} // namespace Tru64
diff --git a/kern/tru64/dump_mbuf.hh b/kern/tru64/dump_mbuf.hh
new file mode 100644
index 000000000..6052fa56a
--- /dev/null
+++ b/kern/tru64/dump_mbuf.hh
@@ -0,0 +1,38 @@
+/*
+ * Copyright (c) 2003 The Regents of The University of Michigan
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met: redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer;
+ * redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution;
+ * neither the name of the copyright holders nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef __DUMP_MBUF_HH__
+#define __DUMP_MBUF_HH__
+
+class AlphaArguments;
+
+namespace Tru64 {
+    void DumpMbuf(AlphaArguments args);
+}
+
+#endif // __DUMP_MBUF_HH__
diff --git a/kern/tru64/printf.cc b/kern/tru64/printf.cc
index 3dd1ee664..65e78d0fa 100644
--- a/kern/tru64/printf.cc
+++ b/kern/tru64/printf.cc
@@ -37,6 +37,8 @@
 
 using namespace std;
 
+namespace Tru64 {
+
 void
 Printf(AlphaArguments args)
 {
@@ -260,3 +262,5 @@ Printf(AlphaArguments args)
     DebugOut().fill(old_fill);
     DebugOut().precision(old_precision);
 }
+
+} // namespace Tru64
diff --git a/kern/tru64/printf.hh b/kern/tru64/printf.hh
new file mode 100644
index 000000000..16129802c
--- /dev/null
+++ b/kern/tru64/printf.hh
@@ -0,0 +1,38 @@
+/*
+ * Copyright (c) 2003 The Regents of The University of Michigan
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met: redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer;
+ * redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution;
+ * neither the name of the copyright holders nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef __PRINTF_HH__
+#define __PRINTF_HH__
+
+class AlphaArguments;
+
+namespace Tru64 {
+    void Printf(AlphaArguments args);
+}
+
+#endif // __PRINTF_HH__
diff --git a/kern/tru64/tru64_events.cc b/kern/tru64/tru64_events.cc
new file mode 100644
index 000000000..ac25129e6
--- /dev/null
+++ b/kern/tru64/tru64_events.cc
@@ -0,0 +1,106 @@
+/*
+ * Copyright (c) 2003 The Regents of The University of Michigan
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met: redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer;
+ * redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution;
+ * neither the name of the copyright holders nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "cpu/exec_context.hh"
+#include "cpu/full_cpu/bpred.hh"
+#include "cpu/full_cpu/cpu.hh"
+#include "kern/tru64/dump_mbuf.hh"
+#include "kern/tru64/printf.hh"
+#include "kern/tru64/tru64_events.hh"
+#include "mem/functional_mem/memory_control.hh"
+#include "targetarch/arguments.hh"
+
+void
+SkipFuncEvent::process(ExecContext *xc)
+{
+    Addr newpc = xc->regs.intRegFile[ReturnAddressReg];
+
+    DPRINTF(PCEvent, "skipping %s: pc=%x, newpc=%x\n", description,
+            xc->regs.pc, newpc);
+
+    xc->regs.pc = newpc;
+    xc->regs.npc = xc->regs.pc + sizeof(MachInst);
+
+    BranchPred *bp = xc->cpu->getBranchPred();
+    if (bp != NULL) {
+        bp->popRAS(xc->thread_num);
+    }
+}
+
+void
+BadAddrEvent::process(ExecContext *xc)
+{
+    // The following gross hack is the equivalent function to the
+    // annotation for vmunix::badaddr in:
+    // simos/simulation/apps/tcl/osf/tlaser.tcl
+
+    uint64_t a0 = xc->regs.intRegFile[ArgumentReg0];
+
+    if (a0 < ALPHA_K0SEG_BASE || a0 >= ALPHA_K1SEG_BASE ||
+        xc->memCtrl->badaddr(ALPHA_K0SEG_TO_PHYS(a0) & PA_IMPL_MASK)) {
+
+        DPRINTF(BADADDR, "badaddr arg=%#x bad\n", a0);
+        xc->regs.intRegFile[ReturnValueReg] = 0x1;
+        SkipFuncEvent::process(xc);
+    }
+    else
+        DPRINTF(BADADDR, "badaddr arg=%#x good\n", a0);
+}
+
+void
+PrintfEvent::process(ExecContext *xc)
+{
+    if (DTRACE(Printf)) {
+        DebugOut() << curTick << ": " << xc->cpu->name() << ": ";
+
+        AlphaArguments args(xc);
+        Tru64::Printf(args);
+    }
+}
+
+void
+DebugPrintfEvent::process(ExecContext *xc)
+{
+    if (DTRACE(DebugPrintf)) {
+        if (!raw)
+            DebugOut() << curTick << ": " << xc->cpu->name() << ": ";
+
+        AlphaArguments args(xc);
+        Tru64::Printf(args);
+    }
+}
+
+void
+DumpMbufEvent::process(ExecContext *xc)
+{
+    if (DTRACE(DebugPrintf)) {
+        AlphaArguments args(xc);
+        Tru64::DumpMbuf(args);
+    }
+}
+
diff --git a/kern/tru64/tru64_events.hh b/kern/tru64/tru64_events.hh
new file mode 100644
index 000000000..d41f82f5b
--- /dev/null
+++ b/kern/tru64/tru64_events.hh
@@ -0,0 +1,81 @@
+/*
+ * Copyright (c) 2003 The Regents of The University of Michigan
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met: redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer;
+ * redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution;
+ * neither the name of the copyright holders nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef __TRU64_EVENTS_HH__
+#define __TRU64_EVENTS_HH__
+
+#include <string>
+
+#include "cpu/pc_event.hh"
+
+class ExecContext;
+
+class SkipFuncEvent : public PCEvent
+{
+  public:
+    SkipFuncEvent(PCEventQueue *q, const std::string &desc)
+        : PCEvent(q, desc) {}
+    virtual void process(ExecContext *xc);
+};
+
+class BadAddrEvent : public SkipFuncEvent
+{
+  public:
+    BadAddrEvent(PCEventQueue *q, const std::string &desc)
+        : SkipFuncEvent(q, desc) {}
+    virtual void process(ExecContext *xc);
+};
+
+class PrintfEvent : public PCEvent
+{
+  public:
+    PrintfEvent(PCEventQueue *q, const std::string &desc)
+        : PCEvent(q, desc) {}
+    virtual void process(ExecContext *xc);
+};
+
+class DebugPrintfEvent : public PCEvent
+{
+  private:
+    bool raw;
+
+  public:
+    DebugPrintfEvent(PCEventQueue *q, const std::string &desc, bool r = false)
+        : PCEvent(q, desc), raw(r) {}
+    virtual void process(ExecContext *xc);
+};
+
+class DumpMbufEvent : public PCEvent
+{
+  public:
+    DumpMbufEvent(PCEventQueue *q, const std::string &desc)
+        : PCEvent(q, desc) {}
+    virtual void process(ExecContext *xc);
+};
+
+#endif // __TRU64_EVENTS_HH__
diff --git a/kern/tru64/tru64_system.cc b/kern/tru64/tru64_system.cc
new file mode 100644
index 000000000..02b6c4fae
--- /dev/null
+++ b/kern/tru64/tru64_system.cc
@@ -0,0 +1,239 @@
+/*
+ * Copyright (c) 2003 The Regents of The University of Michigan
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met: redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer;
+ * redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution;
+ * neither the name of the copyright holders nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "base/remote_gdb.hh"
+#include "base/trace.hh"
+#include "base/loader/aout_object.hh"
+#include "base/loader/ecoff_object.hh"
+#include "base/loader/object_file.hh"
+#include "base/loader/symtab.hh"
+#include "cpu/exec_context.hh"
+#include "kern/tru64/tru64_events.hh"
+#include "kern/tru64/tru64_system.hh"
+#include "mem/functional_mem/memory_control.hh"
+#include "mem/functional_mem/physical_memory.hh"
+#include "targetarch/isa_traits.hh"
+#include "targetarch/vtophys.hh"
+
+using namespace std;
+
+Tru64System::Tru64System(const string _name, MemoryController *_memCtrl,
+                         PhysicalMemory *_physmem, const string &kernel_path,
+                         const string &console_path, const string &palcode,
+                         const string &boot_osflags)
+     : System(_name, _memCtrl, _physmem)
+{
+    kernelSymtab = new SymbolTable;
+    consoleSymtab = new SymbolTable;
+
+    ObjectFile *kernel = createObjectFile(kernel_path);
+    if (kernel == NULL)
+        fatal("Could not load kernel file %s", kernel_path);
+
+    ObjectFile *console = createObjectFile(console_path);
+    if (console == NULL)
+        fatal("Could not load console file %s", console_path);
+
+    if (!kernel->loadGlobalSymbols(kernelSymtab))
+        panic("could not load kernel symbols\n");
+
+    if (!console->loadGlobalSymbols(consoleSymtab))
+        panic("could not load console symbols\n");
+
+    // Load pal file
+    ObjectFile *pal = createObjectFile(palcode);
+    if (pal == NULL)
+        fatal("Could not load PALcode file %s", palcode);
+    pal->loadSections(physmem, true);
+
+    // copy of initial reg file contents
+    initRegs = new RegFile;
+    memset(initRegs, 0, sizeof(RegFile));
+
+    // Load console file
+    console->loadSections(physmem, true);
+
+    // Load kernel file
+    kernel->loadSections(physmem, true);
+    kernelStart = kernel->textBase();
+    kernelEnd = kernel->bssBase() + kernel->bssSize();
+    kernelEntry = kernel->entryPoint();
+
+    DPRINTF(Loader, "Kernel start = %#x\n"
+            "Kernel end   = %#x\n"
+            "Kernel entry = %#x\n",
+            kernelStart, kernelEnd, kernelEntry);
+
+    // Setup kernel boot parameters
+    initRegs->pc = 0x4001;
+    initRegs->npc = initRegs->pc + sizeof(MachInst);
+
+    DPRINTF(Loader, "Kernel loaded...\n");
+
+    kernelPanicEvent = new BreakPCEvent(&pcEventQueue, "kernel panic");
+    consolePanicEvent = new BreakPCEvent(&pcEventQueue, "console panic");
+    badaddrEvent = new BadAddrEvent(&pcEventQueue, "badaddr");
+    skipPowerStateEvent = new SkipFuncEvent(&pcEventQueue,
+                                            "tl_v48_capture_power_state");
+    skipScavengeBootEvent = new SkipFuncEvent(&pcEventQueue,
+                                              "pmap_scavenge_boot");
+    printfEvent = new PrintfEvent(&pcEventQueue, "printf");
+    debugPrintfEvent = new DebugPrintfEvent(&pcEventQueue,
+                                            "debug_printf", false);
+    debugPrintfrEvent = new DebugPrintfEvent(&pcEventQueue,
+                                             "debug_printfr", true);
+    dumpMbufEvent = new DumpMbufEvent(&pcEventQueue, "dump_mbuf");
+
+    Addr addr = 0;
+    if (kernelSymtab->findAddress("enable_async_printf", addr)) {
+        Addr paddr = vtophys(physmem, addr);
+        uint8_t *enable_async_printf =
+            physmem->dma_addr(paddr, sizeof(uint32_t));
+
+        if (enable_async_printf)
+            *(uint32_t *)enable_async_printf = 0;
+    }
+
+    if (consoleSymtab->findAddress("env_booted_osflags", addr)) {
+        Addr paddr = vtophys(physmem, addr);
+        char *osflags = (char *)physmem->dma_addr(paddr, sizeof(uint32_t));
+
+        if (osflags)
+            strcpy(osflags, boot_osflags.c_str());
+    }
+
+    if (kernelSymtab->findAddress("panic", addr))
+        kernelPanicEvent->schedule(addr);
+    else
+        panic("could not find kernel symbol \'panic\'");
+
+    if (consoleSymtab->findAddress("panic", addr))
+        consolePanicEvent->schedule(addr);
+
+    if (kernelSymtab->findAddress("badaddr", addr))
+        badaddrEvent->schedule(addr);
+    else
+        panic("could not find kernel symbol \'badaddr\'");
+
+    if (kernelSymtab->findAddress("tl_v48_capture_power_state", addr))
+        skipPowerStateEvent->schedule(addr);
+
+    if (kernelSymtab->findAddress("pmap_scavenge_boot", addr))
+        skipScavengeBootEvent->schedule(addr);
+
+#if TRACING_ON
+    if (kernelSymtab->findAddress("printf", addr))
+        printfEvent->schedule(addr);
+
+    if (kernelSymtab->findAddress("m5printf", addr))
+        debugPrintfEvent->schedule(addr);
+
+    if (kernelSymtab->findAddress("m5printfr", addr))
+        debugPrintfrEvent->schedule(addr);
+
+    if (kernelSymtab->findAddress("m5_dump_mbuf", addr))
+        dumpMbufEvent->schedule(addr);
+#endif
+}
+
+Tru64System::~Tru64System()
+{
+    delete initRegs;
+
+    delete kernel;
+    delete console;
+
+    delete kernelSymtab;
+    delete consoleSymtab;
+
+    delete kernelPanicEvent;
+    delete consolePanicEvent;
+    delete badaddrEvent;
+    delete skipPowerStateEvent;
+    delete skipScavengeBootEvent;
+    delete printfEvent;
+    delete debugPrintfEvent;
+    delete debugPrintfrEvent;
+    delete dumpMbufEvent;
+
+}
+
+void
+Tru64System::init(ExecContext *xc)
+{
+    xc->regs = *initRegs;
+
+    remoteGDB = new RemoteGDB(this, xc);
+    gdbListen = new GDBListener(remoteGDB, 7000);
+    gdbListen->listen();
+
+    // Reset the system
+    //
+    TheISA::init(physmem, &xc->regs);
+}
+
+bool
+Tru64System::breakpoint()
+{
+    return remoteGDB->trap(ALPHA_KENTRY_IF);
+}
+
+BEGIN_DECLARE_SIM_OBJECT_PARAMS(Tru64System)
+
+    SimObjectParam<MemoryController *> mem_ctl;
+    SimObjectParam<PhysicalMemory *> physmem;
+
+    Param<string> kernel_code;
+    Param<string> console_code;
+    Param<string> pal_code;
+    Param<string> boot_osflags;
+
+END_DECLARE_SIM_OBJECT_PARAMS(Tru64System)
+
+BEGIN_INIT_SIM_OBJECT_PARAMS(Tru64System)
+
+    INIT_PARAM(mem_ctl, "memory controller"),
+    INIT_PARAM(physmem, "phsyical memory"),
+    INIT_PARAM(kernel_code, "file that contains the kernel code"),
+    INIT_PARAM(console_code, "file that contains the console code"),
+    INIT_PARAM(pal_code, "file that contains palcode"),
+    INIT_PARAM_DFLT(boot_osflags, "flags to pass to the kernel during boot",
+                    "a")
+
+END_INIT_SIM_OBJECT_PARAMS(Tru64System)
+
+CREATE_SIM_OBJECT(Tru64System)
+{
+    Tru64System *sys = new Tru64System(getInstanceName(), mem_ctl, physmem,
+                                       kernel_code, console_code, pal_code,
+                                       boot_osflags);
+
+    return sys;
+}
+
+REGISTER_SIM_OBJECT("Tru64System", Tru64System)
diff --git a/kern/tru64/tru64_system.hh b/kern/tru64/tru64_system.hh
new file mode 100644
index 000000000..087ef038c
--- /dev/null
+++ b/kern/tru64/tru64_system.hh
@@ -0,0 +1,101 @@
+/*
+ * Copyright (c) 2003 The Regents of The University of Michigan
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met: redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer;
+ * redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution;
+ * neither the name of the copyright holders nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef __TRU64_SYSTEM_HH__
+#define __TRU64_SYSTEM_HH__
+
+#include "sim/system.hh"
+#include "targetarch/isa_traits.hh"
+
+class ExecContext;
+class EcoffObject;
+class SymbolTable;
+
+class BreakPCEvent;
+class BadAddrEvent;
+class SkipFuncEvent;
+class PrintfEvent;
+class DebugPrintfEvent;
+class DumpMbufEvent;
+
+class AlphaArguments;
+
+class Tru64System : public System
+{
+  private:
+    ExecContext *xc;
+
+    EcoffObject *kernel;
+    EcoffObject *console;
+
+    SymbolTable *kernelSymtab;
+    SymbolTable *consoleSymtab;
+
+    BreakPCEvent *kernelPanicEvent;
+    BreakPCEvent *consolePanicEvent;
+    BadAddrEvent *badaddrEvent;
+    SkipFuncEvent *skipPowerStateEvent;
+    SkipFuncEvent *skipScavengeBootEvent;
+    PrintfEvent *printfEvent;
+    DebugPrintfEvent *debugPrintfEvent;
+    DebugPrintfEvent *debugPrintfrEvent;
+    DumpMbufEvent *dumpMbufEvent;
+
+  private:
+    RegFile *initRegs;
+
+    Addr kernelStart;
+    Addr kernelEnd;
+    Addr kernelEntry;
+
+  public:
+    RemoteGDB *remoteGDB;
+    GDBListener *gdbListen;
+
+  public:
+    Tru64System(const std::string _name,
+                MemoryController *_memCtrl,
+                PhysicalMemory *_physmem,
+                const std::string &kernel_path,
+                const std::string &console_path,
+                const std::string &palcode,
+                const std::string &boot_osflags);
+    ~Tru64System();
+
+    void init(ExecContext *xc);
+
+    Addr getKernelStart() const { return kernelStart; }
+    Addr getKernelEnd() const { return kernelEnd; }
+    Addr getKernelEntry() const { return kernelEntry; }
+    bool breakpoint();
+
+    static void Printf(AlphaArguments args);
+    static void DumpMbuf(AlphaArguments args);
+};
+
+#endif // __TRU64_SYSTEM_HH__
diff --git a/sim/system.cc b/sim/system.cc
index 999782e48..fd80e23c3 100644
--- a/sim/system.cc
+++ b/sim/system.cc
@@ -27,14 +27,8 @@
  */
 
 #include "cpu/exec_context.hh"
-#include "base/loader/object_file.hh"
-#include "mem/functional_mem/memory_control.hh"
-#include "mem/functional_mem/physical_memory.hh"
-#include "base/loader/symtab.hh"
-#include "base/remote_gdb.hh"
 #include "targetarch/vtophys.hh"
 #include "sim/system.hh"
-#include "base/trace.hh"
 
 using namespace std;
 
@@ -44,155 +38,18 @@ int System::numSystemsRunning = 0;
 
 System::System(const std::string _name,
                MemoryController *_memCtrl,
-               PhysicalMemory *_physmem,
-               const std::string &kernel_path,
-               const std::string &console_path,
-               const std::string &palcode,
-               const std::string &boot_osflags)
+               PhysicalMemory *_physmem)
     : SimObject(_name),
-      kernel_panic_event(&pcEventQueue, "kernel panic"),
-      console_panic_event(&pcEventQueue, "console panic"),
-      badaddr_event(&pcEventQueue, "badaddr"),
-      skip_power_state(&pcEventQueue, "tl_v48_capture_power_state"),
-      skip_scavenge_boot(&pcEventQueue, "pmap_scavenge_boot"),
-      printf_event(&pcEventQueue, "printf"),
-      debug_printf_event(&pcEventQueue, "debug_printf", false),
-      debug_printfr_event(&pcEventQueue, "debug_printfr", true),
-      dump_mbuf_event(&pcEventQueue, "dump_mbuf"),
       memCtrl(_memCtrl),
-      physmem(_physmem),
-      remoteGDB(NULL),
-      gdbListen(NULL)
+      physmem(_physmem)
 {
-    kernelSymtab = new SymbolTable;
-    consoleSymtab = new SymbolTable;
-
-    ObjectFile *kernel = createObjectFile(kernel_path);
-    if (kernel == NULL)
-        fatal("Could not load kernel file %s", kernel_path);
-
-    ObjectFile *console = createObjectFile(console_path);
-    if (console == NULL)
-        fatal("Could not load console file %s", console_path);
-
-    if (!kernel->loadGlobalSymbols(kernelSymtab))
-        panic("could not load kernel symbols\n");
-
-    if (!console->loadGlobalSymbols(consoleSymtab))
-        panic("could not load console symbols\n");
-
-    // Load pal file
-    ObjectFile *pal = createObjectFile(palcode);
-    if (pal == NULL)
-        fatal("Could not load PALcode file %s", palcode);
-    pal->loadSections(physmem, true);
-
-    // copy of initial reg file contents
-    initRegs = new RegFile;
-    memset(initRegs, 0, sizeof(RegFile));
-
-    // Load console file
-    console->loadSections(physmem, true);
-
-    // Load kernel file
-    kernel->loadSections(physmem, true);
-    kernelStart = kernel->textBase();
-    kernelEnd = kernel->bssBase() + kernel->bssSize();
-    kernelEntry = kernel->entryPoint();
-
-    DPRINTF(Loader, "Kernel start = %#x\n"
-            "Kernel end   = %#x\n"
-            "Kernel entry = %#x\n",
-            kernelStart, kernelEnd, kernelEntry);
-
-    // Setup kernel boot parameters
-    initRegs->pc = 0x4001;
-    initRegs->npc = initRegs->pc + sizeof(MachInst);
-
-    DPRINTF(Loader, "Kernel loaded...\n");
-
-#ifdef FULL_SYSTEM
-    Addr addr = 0;
-
-    if (kernelSymtab->findAddress("enable_async_printf", addr)) {
-        Addr paddr = vtophys(physmem, addr);
-        uint8_t *enable_async_printf =
-            physmem->dma_addr(paddr, sizeof(uint32_t));
-
-        if (enable_async_printf)
-            *(uint32_t *)enable_async_printf = 0;
-    }
-
-    if (consoleSymtab->findAddress("env_booted_osflags", addr)) {
-        Addr paddr = vtophys(physmem, addr);
-        char *osflags = (char *)physmem->dma_addr(paddr, sizeof(uint32_t));
-
-        if (osflags)
-            strcpy(osflags, boot_osflags.c_str());
-    }
-
-    if (kernelSymtab->findAddress("panic", addr))
-        kernel_panic_event.schedule(addr);
-    else
-        panic("could not find kernel symbol \'panic\'");
-
-    if (consoleSymtab->findAddress("panic", addr))
-        console_panic_event.schedule(addr);
-
-    if (kernelSymtab->findAddress("badaddr", addr))
-        badaddr_event.schedule(addr);
-    else
-        panic("could not find kernel symbol \'badaddr\'");
-
-    if (kernelSymtab->findAddress("tl_v48_capture_power_state", addr))
-        skip_power_state.schedule(addr);
-
-    if (kernelSymtab->findAddress("pmap_scavenge_boot", addr))
-        skip_scavenge_boot.schedule(addr);
-
-#if TRACING_ON
-    if (kernelSymtab->findAddress("printf", addr))
-        printf_event.schedule(addr);
-
-    if (kernelSymtab->findAddress("m5printf", addr))
-        debug_printf_event.schedule(addr);
-
-    if (kernelSymtab->findAddress("m5printfr", addr))
-        debug_printfr_event.schedule(addr);
-
-    if (kernelSymtab->findAddress("m5_dump_mbuf", addr))
-        dump_mbuf_event.schedule(addr);
-#endif
-
-#endif
-
     // add self to global system list
     systemList.push_back(this);
-
-    numSystemsRunning++;
 }
 
 
 System::~System()
 {
-    delete kernelSymtab;
-    delete consoleSymtab;
-    delete initRegs;
-}
-
-
-void
-System::initBootContext(ExecContext *xc)
-{
-    xc->regs = *initRegs;
-
-    remoteGDB = new RemoteGDB(this, xc);
-    gdbListen = new GDBListener(remoteGDB, 7000);
-    gdbListen->listen();
-
-    // Reset the system
-    //
-    TheISA::init(physmem, &xc->regs);
 }
 
 
@@ -220,7 +77,6 @@ System::printSystems()
     }
 }
 
-
 extern "C"
 void
 printSystems()
@@ -228,39 +84,5 @@ printSystems()
     System::printSystems();
 }
 
+DEFINE_SIM_OBJECT_CLASS_NAME("System", System)
 
-BEGIN_DECLARE_SIM_OBJECT_PARAMS(System)
-
-    SimObjectParam<MemoryController *> mem_ctl;
-    SimObjectParam<PhysicalMemory *> physmem;
-
-    Param<string> kernel_code;
-    Param<string> console_code;
-    Param<string> pal_code;
-    Param<string> boot_osflags;
-
-END_DECLARE_SIM_OBJECT_PARAMS(System)
-
-BEGIN_INIT_SIM_OBJECT_PARAMS(System)
-
-    INIT_PARAM(mem_ctl, "memory controller"),
-    INIT_PARAM(physmem, "phsyical memory"),
-    INIT_PARAM(kernel_code, "file that contains the kernel code"),
-    INIT_PARAM(console_code, "file that contains the console code"),
-    INIT_PARAM(pal_code, "file that contains palcode"),
-    INIT_PARAM_DFLT(boot_osflags, "flags to pass to the kernel during boot",
-                    "a")
-
-END_INIT_SIM_OBJECT_PARAMS(System)
-
-
-CREATE_SIM_OBJECT(System)
-{
-    System *sys = new System(getInstanceName(), mem_ctl, physmem,
-                             kernel_code, console_code, pal_code,
-                             boot_osflags);
-
-    return sys;
-}
-
-REGISTER_SIM_OBJECT("System", System)
diff --git a/sim/system.hh b/sim/system.hh
index 3ab514bfa..bec1011ce 100644
--- a/sim/system.hh
+++ b/sim/system.hh
@@ -45,66 +45,35 @@ class ExecContext;
 
 class System : public SimObject
 {
-  private:
-
-    SymbolTable *kernelSymtab;
-    SymbolTable *consoleSymtab;
-
-    BreakPCEvent kernel_panic_event;
-    BreakPCEvent console_panic_event;
-    BadAddrEvent badaddr_event;
-    SkipFuncEvent skip_power_state;
-    SkipFuncEvent skip_scavenge_boot;
-    PrintfEvent printf_event;
-    DebugPrintfEvent debug_printf_event;
-    DebugPrintfEvent debug_printfr_event;
-    DumpMbufEvent dump_mbuf_event;
-
-    RegFile *initRegs;
-
-    Addr kernelStart;
-    Addr kernelEnd;
-    Addr kernelEntry;
-
   public:
-
     MemoryController *memCtrl;
     PhysicalMemory *physmem;
 
     PCEventQueue pcEventQueue;
 
     std::vector<ExecContext *> xcvec;
+    void registerExecContext(ExecContext *xc);
 
-    RemoteGDB *remoteGDB;
-    GDBListener *gdbListen;
-
-    System(const std::string name,
-           MemoryController *, PhysicalMemory *,
-           const std::string &kernel_path, const std::string &console_path,
-           const std::string &palcode, const std::string &boot_osflags);
-
+  public:
+    System(const std::string name, MemoryController *, PhysicalMemory *);
     ~System();
 
-    const SymbolTable *getKernelSymtab() const { return kernelSymtab; }
-    const SymbolTable *getConsoleSymtab() const { return consoleSymtab; }
+    virtual void init(ExecContext *xc) = 0;
 
-    Addr getKernelStart() const { return kernelStart; }
-    Addr getKernelEnd() const { return kernelEnd; }
-    Addr getKernelEntry() const { return kernelEntry; }
+    virtual Addr getKernelStart() const = 0;
+    virtual Addr getKernelEnd() const = 0;
+    virtual Addr getKernelEntry() const = 0;
+    virtual bool breakpoint() = 0;
 
-    void initBootContext(ExecContext *xc);
-    void registerExecContext(ExecContext *xc);
 
+  public:
     ////////////////////////////////////////////
     //
     // STATIC GLOBAL SYSTEM LIST
     //
     ////////////////////////////////////////////
 
-  public:
-
     static std::vector<System *> systemList;
-
     static int numSystemsRunning;
 
     static void printSystems();