base,cpu,sim: Stop including arch/vtophys.hh when not using vtophys.

[gem5.git] / src / cpu / pc_event.hh

diff --git a/src/cpu/pc_event.hh b/src/cpu/pc_event.hh
index 6b048b2c26f48d7013f09b5fbd5375596273be02..4d2a53ea62c5ac33a1a329bd8c3f020e576a3008 100644 (file)
--- a/src/cpu/pc_event.hh
+++ b/src/cpu/pc_event.hh
@@ -24,9 +24,6 @@
  * 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.
- *
- * Authors: Nathan Binkert
- *          Steve Reinhardt
  */
 
 #ifndef __PC_EVENT_HH__
@@ -34,22 +31,25 @@
 
 #include <vector>
 
-#include "base/misc.hh"
+#include "base/logging.hh"
+#include "base/types.hh"
 
 class ThreadContext;
 class PCEventQueue;
+class System;
+class PCEventScope;
 
 class PCEvent
 {
   protected:
     std::string description;
-    PCEventQueue *queue;
+    PCEventScope *scope;
     Addr evpc;
 
   public:
-    PCEvent(PCEventQueue *q, const std::string &desc, Addr pc);
+    PCEvent(PCEventScope *q, const std::string &desc, Addr pc);
 
-    virtual ~PCEvent() { if (queue) remove(); }
+    virtual ~PCEvent() { if (scope) remove(); }
 
     // for DPRINTF
     virtual const std::string name() const { return description; }
@@ -61,49 +61,61 @@ class PCEvent
     virtual void process(ThreadContext *tc) = 0;
 };
 
-class PCEventQueue
+class PCEventScope
+{
+  public:
+    virtual bool remove(PCEvent *event) = 0;
+    virtual bool schedule(PCEvent *event) = 0;
+};
+
+class PCEventQueue : public PCEventScope
 {
   protected:
-    typedef PCEvent * record_t;
     class MapCompare {
       public:
-        bool operator()(const record_t &l, const record_t &r) const {
+        bool
+        operator()(PCEvent * const &l, PCEvent * const &r) const
+        {
             return l->pc() < r->pc();
         }
-        bool operator()(const record_t &l, Addr pc) const {
+        bool
+        operator()(PCEvent * const &l, Addr pc) const
+        {
             return l->pc() < pc;
         }
-        bool operator()(Addr pc, const record_t &r) const {
+        bool
+        operator()(Addr pc, PCEvent * const &r) const
+        {
             return pc < r->pc();
         }
     };
-    typedef std::vector<record_t> map_t;
+    typedef std::vector<PCEvent *> Map;
 
   public:
-    typedef map_t::iterator iterator;
-    typedef map_t::const_iterator const_iterator;
+    typedef Map::iterator iterator;
+    typedef Map::const_iterator const_iterator;
 
   protected:
     typedef std::pair<iterator, iterator> range_t;
     typedef std::pair<const_iterator, const_iterator> const_range_t;
 
   protected:
-    map_t pc_map;
+    Map pcMap;
 
-    bool doService(ThreadContext *tc);
+    bool doService(Addr pc, ThreadContext *tc);
 
   public:
     PCEventQueue();
     ~PCEventQueue();
 
-    bool remove(PCEvent *event);
-    bool schedule(PCEvent *event);
-    bool service(ThreadContext *tc)
+    bool remove(PCEvent *event) override;
+    bool schedule(PCEvent *event) override;
+    bool service(Addr pc, ThreadContext *tc)
     {
-        if (pc_map.empty())
+        if (pcMap.empty())
             return false;
 
-        return doService(tc);
+        return doService(pc, tc);
     }
 
     range_t equal_range(Addr pc);
@@ -114,19 +126,19 @@ class PCEventQueue
 
 
 inline
-PCEvent::PCEvent(PCEventQueue *q, const std::string &desc, Addr pc)
-    : description(desc), queue(q), evpc(pc)
+PCEvent::PCEvent(PCEventScope *s, const std::string &desc, Addr pc)
+    : description(desc), scope(s), evpc(pc)
 {
-    queue->schedule(this);
+    scope->schedule(this);
 }
 
 inline bool
 PCEvent::remove()
 {
-    if (!queue)
+    if (!scope)
         panic("cannot remove an uninitialized event;");
 
-    return queue->remove(this);
+    return scope->remove(this);
 }
 
 class BreakPCEvent : public PCEvent
@@ -135,9 +147,16 @@ class BreakPCEvent : public PCEvent
     bool remove;
 
   public:
-    BreakPCEvent(PCEventQueue *q, const std::string &desc, Addr addr,
+    BreakPCEvent(PCEventScope *s, const std::string &desc, Addr addr,
                  bool del = false);
     virtual void process(ThreadContext *tc);
 };
 
+class PanicPCEvent : public PCEvent
+{
+  public:
+    PanicPCEvent(PCEventScope *s, const std::string &desc, Addr pc);
+    virtual void process(ThreadContext *tc);
+};
+
 #endif // __PC_EVENT_HH__