case PAL::bpt:
case PAL::bugchk:
- if (system->remoteGDB->trap(ALPHA_KENTRY_IF))
+ if (system->breakpoint())
return false;
break;
}
#ifndef __REMOTE_GDB_HH__
#define __REMOTE_GDB_HH__
+#include <map>
+
#include "base/kgdb.h"
#include "cpu/pc_event.hh"
#include "base/pollevent.hh"
#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()
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)
{
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:
virtual void process(ExecContext *xc);
};
-
#endif // __PC_EVENT_HH__
_status = Idle;
}
else {
- system->initBootContext(xc);
+ system->init(xc);
// Reset the system
//
#include "targetarch/isa_traits.hh"
#include "targetarch/vtophys.hh"
+namespace Tru64 {
+
void
DumpMbuf(AlphaArguments args)
{
CopyData(xc, &m, m.m_next, sizeof(m));
}
}
+
+} // namespace Tru64
--- /dev/null
+/*
+ * 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__
using namespace std;
+namespace Tru64 {
+
void
Printf(AlphaArguments args)
{
DebugOut().fill(old_fill);
DebugOut().precision(old_precision);
}
+
+} // namespace Tru64
--- /dev/null
+/*
+ * 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__
--- /dev/null
+/*
+ * 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);
+ }
+}
+
--- /dev/null
+/*
+ * 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__
--- /dev/null
+/*
+ * 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)
--- /dev/null
+/*
+ * 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__
*/
#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;
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);
}
}
}
-
extern "C"
void
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)
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();
projects / gem5.git / commitdiff