Add functions to System object to set up function-based events,

including automatically fixing up addresses to deal with
optionally executed Alpha gp update prolog.

SConscript:
    Remove freebsd_events.cc and linux_events.cc.
base/remote_gdb.cc:
cpu/pc_event.cc:
kern/system_events.cc:
kern/system_events.hh:
    PCEvents now schedule themselves in constructor.
cpu/pc_event.hh:
    PCEvents now schedule themselves in the constructor.
    Get rid of constructor versions that don't take an address and
    all the schedule() methods that are now unnecessary.
kern/freebsd/freebsd_system.cc:
kern/freebsd/freebsd_system.hh:
    Use new System methods to schedule function-based events.
    Move FreeBSD-specific function event classes into FreebsdSystem.
kern/linux/linux_system.cc:
kern/linux/linux_system.hh:
    Use new System methods to schedule function-based events.
    Move Linux-specific function event classes into LinuxSystem.
kern/tru64/tru64_events.hh:
    PCEvents now schedule themselves in constructor.
    Add DebugPrintfrEvent to encapsulate raw setting as new type
    (to work better with new System function-event method.)
kern/tru64/tru64_system.cc:
    Use new System methods to schedule function-based events.
kern/tru64/tru64_system.hh:
    Add DebugPrintfrEvent to encapsulate raw setting as new type
    (to work better with new System function-event method.)
sim/system.cc:
sim/system.hh:
    Add functions to set up function-based events, including
    automatically fixing up addresses to deal with optionally
    executed Alpha gp update prolog.

--HG--
extra : convert_revision : c2cf09144297b6602afe755a34a0a2227023783f

9 files changed, 164 insertions, 127 deletions

diff --git a/kern/freebsd/freebsd_system.cc b/kern/freebsd/freebsd_system.cc
index 5e0ce113b..283713d40 100644
--- a/kern/freebsd/freebsd_system.cc
+++ b/kern/freebsd/freebsd_system.cc
@@ -48,18 +48,13 @@ using namespace std;
 FreebsdSystem::FreebsdSystem(Params *p)
     : System(p)
 {
-    Addr addr = 0;
-
     /**
      * Any time DELAY is called just skip the function.
+     * Shouldn't we actually emulate the delay?
      */
-    skipDelayEvent = new SkipFuncEvent(&pcEventQueue, "DELAY");
-    if (kernelSymtab->findAddress("DELAY", addr))
-        skipDelayEvent->schedule(addr+sizeof(MachInst));
-
-    skipCalibrateClocks = new FreebsdSkipCalibrateClocksEvent(&pcEventQueue, "calibrate_clocks");
-    if (kernelSymtab->findAddress("calibrate_clocks", addr))
-        skipCalibrateClocks->schedule(addr + sizeof(MachInst) * 2);
+    skipDelayEvent = addKernelFuncEvent<SkipFuncEvent>("DELAY");
+    skipCalibrateClocks =
+        addKernelFuncEvent<SkipCalibrateClocksEvent>("calibrate_clocks");
 }
 
 
@@ -92,6 +87,14 @@ FreebsdSystem::doCalibrateClocks(ExecContext *xc)
 }
 
 
+void
+FreebsdSystem::SkipCalibrateClocksEvent::process(ExecContext *xc)
+{
+    SkipFuncEvent::process(xc);
+    ((FreebsdSystem *)xc->system)->doCalibrateClocks(xc);
+}
+
+
 BEGIN_DECLARE_SIM_OBJECT_PARAMS(FreebsdSystem)
 
     Param<Tick> boot_cpu_frequency;
diff --git a/kern/freebsd/freebsd_system.hh b/kern/freebsd/freebsd_system.hh
index 6429b5690..ecb842ec6 100644
--- a/kern/freebsd/freebsd_system.hh
+++ b/kern/freebsd/freebsd_system.hh
@@ -29,13 +29,22 @@
 #ifndef __KERN_FREEBSD_FREEBSD_SYSTEM_HH__
 #define __KERN_FREEBSD_FREEBSD_SYSTEM_HH__
 
-#include "kern/freebsd/freebsd_events.hh"
+#include "kern/system_events.hh"
 
 class FreebsdSystem : public System
 {
   private:
+    class SkipCalibrateClocksEvent : public SkipFuncEvent
+    {
+      public:
+        SkipCalibrateClocksEvent(PCEventQueue *q, const std::string &desc,
+                                 Addr addr)
+            : SkipFuncEvent(q, desc, addr) {}
+        virtual void process(ExecContext *xc);
+    };
+
     SkipFuncEvent *skipDelayEvent;
-    FreebsdSkipCalibrateClocksEvent *skipCalibrateClocks;
+    SkipCalibrateClocksEvent *skipCalibrateClocks;
 
   public:
     FreebsdSystem(Params *p);
diff --git a/kern/linux/linux_system.cc b/kern/linux/linux_system.cc
index e3b9990c5..addce0389 100644
--- a/kern/linux/linux_system.cc
+++ b/kern/linux/linux_system.cc
@@ -38,12 +38,14 @@
 #include "base/loader/symtab.hh"
 #include "cpu/exec_context.hh"
 #include "cpu/base.hh"
-#include "kern/linux/linux_events.hh"
 #include "kern/linux/linux_system.hh"
+#include "kern/linux/linux_threadinfo.hh"
+#include "kern/linux/printk.hh"
 #include "mem/functional/memory_control.hh"
 #include "mem/functional/physical.hh"
 #include "sim/builder.hh"
 #include "dev/platform.hh"
+#include "targetarch/arguments.hh"
 #include "targetarch/vtophys.hh"
 
 using namespace std;
@@ -106,80 +108,57 @@ LinuxSystem::LinuxSystem(Params *p)
         panic("could not find dp264_mv\n");
 
 #ifndef NDEBUG
-    kernelPanicEvent = new BreakPCEvent(&pcEventQueue, "kernel panic");
-    if (kernelSymtab->findAddress("panic", addr))
-        kernelPanicEvent->schedule(addr);
-    else
+    kernelPanicEvent = addKernelFuncEvent<BreakPCEvent>("panic");
+    if (!kernelPanicEvent)
         panic("could not find kernel symbol \'panic\'");
+
 #if 0
-    kernelDieEvent = new BreakPCEvent(&pcEventQueue, "die if kernel");
-    if (kernelSymtab->findAddress("die_if_kernel", addr))
-        kernelDieEvent->schedule(addr);
-    else
+    kernelDieEvent = addKernelFuncEvent<BreakPCEvent>("die_if_kernel");
+    if (!kernelDieEvent)
         panic("could not find kernel symbol \'die_if_kernel\'");
 #endif
 
 #endif
 
     /**
-     * Any time ide_delay_50ms, calibarte_delay or
+v     * Any time ide_delay_50ms, calibarte_delay or
      * determine_cpu_caches is called just skip the
      * function. Currently determine_cpu_caches only is used put
      * information in proc, however if that changes in the future we
      * will have to fill in the cache size variables appropriately.
      */
-    skipIdeDelay50msEvent = new SkipFuncEvent(&pcEventQueue, "ide_delay_50ms");
-    if (kernelSymtab->findAddress("ide_delay_50ms", addr))
-        skipIdeDelay50msEvent->schedule(addr+sizeof(MachInst));
-
-    skipDelayLoopEvent = new LinuxSkipDelayLoopEvent(&pcEventQueue,
-                                                     "calibrate_delay");
-    if (kernelSymtab->findAddress("calibrate_delay", addr)) {
-        skipDelayLoopEvent->schedule(addr + 3 * sizeof(MachInst));
-    }
-
-    skipCacheProbeEvent = new SkipFuncEvent(&pcEventQueue,
-                                            "determine_cpu_caches");
-    if (kernelSymtab->findAddress("determine_cpu_caches", addr))
-        skipCacheProbeEvent->schedule(addr+sizeof(MachInst));
-
-    debugPrintkEvent = new DebugPrintkEvent(&pcEventQueue, "dprintk");
-    if (kernelSymtab->findAddress("dprintk", addr))
-        debugPrintkEvent->schedule(addr+8);
-
-    idleStartEvent = new IdleStartEvent(&pcEventQueue, "cpu_idle", this);
-    if (kernelSymtab->findAddress("cpu_idle", addr))
-        idleStartEvent->schedule(addr);
-
-    printThreadEvent = new PrintThreadInfo(&pcEventQueue, "threadinfo");
-    if (kernelSymtab->findAddress("alpha_switch_to", addr) && DTRACE(Thread))
-        printThreadEvent->schedule(addr + sizeof(MachInst) * 6);
 
-    intStartEvent = new InterruptStartEvent(&pcEventQueue, "intStartEvent");
+    skipIdeDelay50msEvent =
+        addKernelFuncEvent<SkipFuncEvent>("ide_delay_50ms");
+    skipDelayLoopEvent =
+        addKernelFuncEvent<SkipDelayLoopEvent>("calibrate_delay");
+    skipCacheProbeEvent =
+        addKernelFuncEvent<SkipFuncEvent>("determine_cpu_caches");
+    debugPrintkEvent = addKernelFuncEvent<DebugPrintkEvent>("dprintk");
+    idleStartEvent = addKernelFuncEvent<IdleStartEvent>("cpu_idle");
+
+    if (kernelSymtab->findAddress("alpha_switch_to", addr) && DTRACE(Thread)) {
+        printThreadEvent = new PrintThreadInfo(&pcEventQueue, "threadinfo",
+                                               addr + sizeof(MachInst) * 6);
+    } else {
+        printThreadEvent = NULL;
+    }
 
     if (params->bin_int) {
-        if (palSymtab->findAddress("sys_int_21", addr))
-            intStartEvent->schedule(addr + sizeof(MachInst) * 2);
-        else
+        intStartEvent = addPalFuncEvent<InterruptStartEvent>("sys_int_21");
+        if (!intStartEvent)
             panic("could not find symbol: sys_int_21\n");
 
-        intEndEvent = new InterruptEndEvent(&pcEventQueue, "intEndEvent");
-        if (palSymtab->findAddress("rti_to_kern", addr))
-            intEndEvent->schedule(addr) ;
-        else
+        intEndEvent = addPalFuncEvent<InterruptEndEvent>("rti_to_kern");
+        if (!intEndEvent)
             panic("could not find symbol: rti_to_kern\n");
 
-        intEndEvent2 = new InterruptEndEvent(&pcEventQueue, "intEndEvent2");
-        if (palSymtab->findAddress("rti_to_user", addr))
-            intEndEvent2->schedule(addr);
-        else
+        intEndEvent2 = addPalFuncEvent<InterruptEndEvent>("rti_to_user");
+        if (!intEndEvent2)
             panic("could not find symbol: rti_to_user\n");
 
-
-        intEndEvent3 = new InterruptEndEvent(&pcEventQueue, "intEndEvent3");
-        if (kernelSymtab->findAddress("do_softirq", addr))
-            intEndEvent3->schedule(addr + sizeof(MachInst) * 2);
-        else
+        intEndEvent3 = addKernelFuncEvent<InterruptEndEvent>("do_softirq");
+        if (!intEndEvent3)
             panic("could not find symbol: do_softirq\n");
     }
 }
@@ -218,6 +197,39 @@ LinuxSystem::setDelayLoop(ExecContext *xc)
     }
 }
 
+void
+LinuxSystem::SkipDelayLoopEvent::process(ExecContext *xc)
+{
+    SkipFuncEvent::process(xc);
+    // calculate and set loops_per_jiffy
+    ((LinuxSystem *)xc->system)->setDelayLoop(xc);
+}
+
+void
+LinuxSystem::DebugPrintkEvent::process(ExecContext *xc)
+{
+    if (DTRACE(DebugPrintf)) {
+        if (!raw) {
+            StringWrap name(xc->system->name() + ".dprintk");
+            DPRINTFN("");
+        }
+
+        AlphaArguments args(xc);
+        Printk(args);
+        SkipFuncEvent::process(xc);
+    }
+}
+
+void
+LinuxSystem::PrintThreadInfo::process(ExecContext *xc)
+{
+    Linux::ThreadInfo ti(xc);
+
+    DPRINTF(Thread, "Currently Executing Thread %s, pid %d, started at: %d\n",
+            ti.curTaskName(), ti.curTaskPID(), ti.curTaskStart());
+}
+
+
 BEGIN_DECLARE_SIM_OBJECT_PARAMS(LinuxSystem)
 
     Param<Tick> boot_cpu_frequency;
diff --git a/kern/linux/linux_system.hh b/kern/linux/linux_system.hh
index 2ddddbc1a..f883bef93 100644
--- a/kern/linux/linux_system.hh
+++ b/kern/linux/linux_system.hh
@@ -32,10 +32,6 @@
 class ExecContext;
 
 class BreakPCEvent;
-class DebugPrintkEvent;
-class BreakPCEvent;
-class LinuxSkipDelayLoopEvent;
-class SkipFuncEvent;
 class IdleStartEvent;
 class PrintThreadInfo;
 
@@ -47,6 +43,34 @@ class PrintThreadInfo;
 class LinuxSystem : public System
 {
   private:
+    class SkipDelayLoopEvent : public SkipFuncEvent
+    {
+      public:
+        SkipDelayLoopEvent(PCEventQueue *q, const std::string &desc, Addr addr)
+            : SkipFuncEvent(q, desc, addr) {}
+        virtual void process(ExecContext *xc);
+    };
+
+    class DebugPrintkEvent : public SkipFuncEvent
+    {
+      private:
+        bool raw;
+
+      public:
+        DebugPrintkEvent(PCEventQueue *q, const std::string &desc, Addr addr,
+                         bool r = false)
+            : SkipFuncEvent(q, desc, addr), raw(r) {}
+        virtual void process(ExecContext *xc);
+    };
+
+    class PrintThreadInfo : public PCEvent
+    {
+      public:
+        PrintThreadInfo(PCEventQueue *q, const std::string &desc, Addr addr)
+            : PCEvent(q, desc, addr) {}
+        virtual void process(ExecContext *xc);
+    };
+
     /**
      * Addresses defining where the kernel bootloader places various
      * elements.  Details found in include/asm-alpha/system.h
@@ -94,7 +118,7 @@ class LinuxSystem : public System
      * Skip calculate_delay_loop() rather than waiting for this to be
      * calculated
      */
-    LinuxSkipDelayLoopEvent *skipDelayLoopEvent;
+    SkipDelayLoopEvent *skipDelayLoopEvent;
 
     /**
      * Event to print information about thread switches if the trace flag
diff --git a/kern/system_events.cc b/kern/system_events.cc
index d5c0d242a..ba3c9274a 100644
--- a/kern/system_events.cc
+++ b/kern/system_events.cc
@@ -47,8 +47,9 @@ SkipFuncEvent::process(ExecContext *xc)
 }
 
 
-FnEvent::FnEvent(PCEventQueue *q, const std::string &desc, Stats::MainBin *bin)
-    : PCEvent(q, desc), _name(desc), mybin(bin)
+FnEvent::FnEvent(PCEventQueue *q, const std::string &desc, Addr addr,
+                 Stats::MainBin *bin)
+    : PCEvent(q, desc, addr), _name(desc), mybin(bin)
 {
 }
 
diff --git a/kern/system_events.hh b/kern/system_events.hh
index 94f6efeba..246140a09 100644
--- a/kern/system_events.hh
+++ b/kern/system_events.hh
@@ -29,20 +29,24 @@
 #ifndef __SYSTEM_EVENTS_HH__
 #define __SYSTEM_EVENTS_HH__
 
+#include "cpu/pc_event.hh"
+
 class System;
 
 class SkipFuncEvent : public PCEvent
 {
   public:
-    SkipFuncEvent(PCEventQueue *q, const std::string &desc)
-        : PCEvent(q, desc) {}
+    SkipFuncEvent(PCEventQueue *q, const std::string &desc, Addr addr)
+        : PCEvent(q, desc, addr)
+    {}
     virtual void process(ExecContext *xc);
 };
 
 class FnEvent : public PCEvent
 {
   public:
-    FnEvent(PCEventQueue *q, const std::string &desc, Stats::MainBin *bin);
+    FnEvent(PCEventQueue *q, const std::string &desc, Addr addr,
+            Stats::MainBin *bin);
     virtual void process(ExecContext *xc);
     std::string myname() const { return _name; }
 
@@ -53,12 +57,9 @@ class FnEvent : public PCEvent
 
 class IdleStartEvent : public PCEvent
 {
-  private:
-    System *system;
-
   public:
-    IdleStartEvent(PCEventQueue *q, const std::string &desc, System *sys)
-        : PCEvent(q, desc), system(sys)
+    IdleStartEvent(PCEventQueue *q, const std::string &desc, Addr addr)
+        : PCEvent(q, desc, addr)
     {}
     virtual void process(ExecContext *xc);
 };
@@ -66,8 +67,8 @@ class IdleStartEvent : public PCEvent
 class InterruptStartEvent : public PCEvent
 {
   public:
-    InterruptStartEvent(PCEventQueue *q, const std::string &desc)
-        : PCEvent(q, desc)
+    InterruptStartEvent(PCEventQueue *q, const std::string &desc, Addr addr)
+        : PCEvent(q, desc, addr)
     {}
     virtual void process(ExecContext *xc);
 };
@@ -75,8 +76,8 @@ class InterruptStartEvent : public PCEvent
 class InterruptEndEvent : public PCEvent
 {
   public:
-    InterruptEndEvent(PCEventQueue *q, const std::string &desc)
-        : PCEvent(q, desc)
+    InterruptEndEvent(PCEventQueue *q, const std::string &desc, Addr addr)
+        : PCEvent(q, desc, addr)
     {}
     virtual void process(ExecContext *xc);
 };
diff --git a/kern/tru64/tru64_events.hh b/kern/tru64/tru64_events.hh
index d3b6d6f8c..9b5bcfea2 100644
--- a/kern/tru64/tru64_events.hh
+++ b/kern/tru64/tru64_events.hh
@@ -39,16 +39,16 @@ class ExecContext;
 class BadAddrEvent : public SkipFuncEvent
 {
   public:
-    BadAddrEvent(PCEventQueue *q, const std::string &desc)
-        : SkipFuncEvent(q, desc) {}
+    BadAddrEvent(PCEventQueue *q, const std::string &desc, Addr addr)
+        : SkipFuncEvent(q, desc, addr) {}
     virtual void process(ExecContext *xc);
 };
 
 class PrintfEvent : public PCEvent
 {
   public:
-    PrintfEvent(PCEventQueue *q, const std::string &desc)
-        : PCEvent(q, desc) {}
+    PrintfEvent(PCEventQueue *q, const std::string &desc, Addr addr)
+        : PCEvent(q, desc, addr) {}
     virtual void process(ExecContext *xc);
 };
 
@@ -58,16 +58,25 @@ class DebugPrintfEvent : public PCEvent
     bool raw;
 
   public:
-    DebugPrintfEvent(PCEventQueue *q, const std::string &desc, bool r = false)
-        : PCEvent(q, desc), raw(r) {}
+    DebugPrintfEvent(PCEventQueue *q, const std::string &desc, Addr addr,
+                     bool r = false)
+        : PCEvent(q, desc, addr), raw(r) {}
     virtual void process(ExecContext *xc);
 };
 
+class DebugPrintfrEvent : public DebugPrintfEvent
+{
+  public:
+    DebugPrintfrEvent(PCEventQueue *q, const std::string &desc, Addr addr)
+        : DebugPrintfEvent(q, desc, addr, true)
+    {}
+};
+
 class DumpMbufEvent : public PCEvent
 {
   public:
-    DumpMbufEvent(PCEventQueue *q, const std::string &desc)
-        : PCEvent(q, desc) {}
+    DumpMbufEvent(PCEventQueue *q, const std::string &desc, Addr addr)
+        : PCEvent(q, desc, addr) {}
     virtual void process(ExecContext *xc);
 };
 
diff --git a/kern/tru64/tru64_system.cc b/kern/tru64/tru64_system.cc
index d4b056c62..f65293474 100644
--- a/kern/tru64/tru64_system.cc
+++ b/kern/tru64/tru64_system.cc
@@ -55,47 +55,25 @@ Tru64System::Tru64System(Tru64System::Params *p)
     }
 
 #ifdef DEBUG
-    kernelPanicEvent = new BreakPCEvent(&pcEventQueue, "kernel panic");
-    if (kernelSymtab->findAddress("panic", addr))
-        kernelPanicEvent->schedule(addr);
-    else
+    kernelPanicEvent = addKernelFuncEvent<BreakPCEvent>("panic");
+    if (!kernelPanicEvent)
         panic("could not find kernel symbol \'panic\'");
 #endif
 
-    badaddrEvent = new BadAddrEvent(&pcEventQueue, "badaddr");
-    if (kernelSymtab->findAddress("badaddr", addr))
-        badaddrEvent->schedule(addr);
-    else
+    badaddrEvent = addKernelFuncEvent<BadAddrEvent>("badaddr");
+    if (!badaddrEvent)
         panic("could not find kernel symbol \'badaddr\'");
 
-    skipPowerStateEvent = new SkipFuncEvent(&pcEventQueue,
-                                            "tl_v48_capture_power_state");
-    if (kernelSymtab->findAddress("tl_v48_capture_power_state", addr))
-        skipPowerStateEvent->schedule(addr);
-
-    skipScavengeBootEvent = new SkipFuncEvent(&pcEventQueue,
-                                              "pmap_scavenge_boot");
-    if (kernelSymtab->findAddress("pmap_scavenge_boot", addr))
-        skipScavengeBootEvent->schedule(addr);
+    skipPowerStateEvent =
+        addKernelFuncEvent<SkipFuncEvent>("tl_v48_capture_power_state");
+    skipScavengeBootEvent =
+        addKernelFuncEvent<SkipFuncEvent>("pmap_scavenge_boot");
 
 #if TRACING_ON
-    printfEvent = new PrintfEvent(&pcEventQueue, "printf");
-    if (kernelSymtab->findAddress("printf", addr))
-        printfEvent->schedule(addr);
-
-    debugPrintfEvent = new DebugPrintfEvent(&pcEventQueue, "debug_printf",
-                                            false);
-    if (kernelSymtab->findAddress("m5printf", addr))
-        debugPrintfEvent->schedule(addr);
-
-    debugPrintfrEvent = new DebugPrintfEvent(&pcEventQueue, "debug_printfr",
-                                             true);
-    if (kernelSymtab->findAddress("m5printfr", addr))
-        debugPrintfrEvent->schedule(addr);
-
-    dumpMbufEvent = new DumpMbufEvent(&pcEventQueue, "dump_mbuf");
-    if (kernelSymtab->findAddress("m5_dump_mbuf", addr))
-        dumpMbufEvent->schedule(addr);
+    printfEvent = addKernelFuncEvent<PrintfEvent>("printf");
+    debugPrintfEvent = addKernelFuncEvent<DebugPrintfEvent>("m5printf");
+    debugPrintfrEvent = addKernelFuncEvent<DebugPrintfrEvent>("m5printfr");
+    dumpMbufEvent = addKernelFuncEvent<DumpMbufEvent>("m5_dump_mbuf");
 #endif
 }
 
diff --git a/kern/tru64/tru64_system.hh b/kern/tru64/tru64_system.hh
index 290b44230..a9077e112 100644
--- a/kern/tru64/tru64_system.hh
+++ b/kern/tru64/tru64_system.hh
@@ -54,8 +54,8 @@ class Tru64System : public System
     SkipFuncEvent *skipPowerStateEvent;
     SkipFuncEvent *skipScavengeBootEvent;
     PrintfEvent *printfEvent;
-    DebugPrintfEvent *debugPrintfEvent;
-    DebugPrintfEvent *debugPrintfrEvent;
+    DebugPrintfEvent  *debugPrintfEvent;
+    DebugPrintfrEvent *debugPrintfrEvent;
     DumpMbufEvent *dumpMbufEvent;
 
   public: