cpu: Fix broken squashAfter implementation in O3 CPU

Commit can currently both commit and squash in the same cycle. This
confuses other stages since the signals coming from the commit stage
can only signal either a squash or a commit in a cycle. This changeset
changes the behavior of squashAfter so that it commits all
instructions, including the instruction that requested the squash, in
the first cycle and then starts to squash in the next cycle.

1 files changed, 41 insertions, 6 deletions

diff --git a/src/cpu/o3/commit.hh b/src/cpu/o3/commit.hh
index fdd9609a4..2d8d88b21 100644
--- a/src/cpu/o3/commit.hh
+++ b/src/cpu/o3/commit.hh
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2010 ARM Limited
+ * Copyright (c) 2010-2012 ARM Limited
  * All rights reserved.
  *
  * The license below extends only to copyright in the software and shall
@@ -129,7 +129,8 @@ class DefaultCommit
         Idle,
         ROBSquashing,
         TrapPending,
-        FetchTrapPending
+        FetchTrapPending,
+        SquashAfterPending, //< Committing instructions before a squash.
     };
 
     /** Commit policy for SMT mode. */
@@ -259,13 +260,38 @@ class DefaultCommit
     /** Handles squashing due to an TC write. */
     void squashFromTC(ThreadID tid);
 
-    /** Handles squashing from instruction with SquashAfter set.
+    /** Handles a squash from a squashAfter() request. */
+    void squashFromSquashAfter(ThreadID tid);
+
+    /**
+     * Handle squashing from instruction with SquashAfter set.
+     *
      * This differs from the other squashes as it squashes following
      * instructions instead of the current instruction and doesn't
-     * clean up various status bits about traps/tc writes pending.
+     * clean up various status bits about traps/tc writes
+     * pending. Since there might have been instructions committed by
+     * the commit stage before the squashing instruction was reached
+     * and we can't commit and squash in the same cycle, we have to
+     * squash in two steps:
+     *
+     * <ol>
+     *   <li>Immediately set the commit status of the thread of
+     *       SquashAfterPending. This forces the thread to stop
+     *       committing instructions in this cycle. The last
+     *       instruction to be committed in this cycle will be the
+     *       SquashAfter instruction.
+     *   <li>In the next cycle, commit() checks for the
+     *       SquashAfterPending state and squashes <i>all</i>
+     *       in-flight instructions. Since the SquashAfter instruction
+     *       was the last instruction to be committed in the previous
+     *       cycle, this causes all subsequent instructions to be
+     *       squashed.
+     * </ol>
+     *
+     * @param tid ID of the thread to squash.
+     * @param head_inst Instruction that requested the squash.
      */
-    void squashAfter(ThreadID tid, DynInstPtr &head_inst,
-            uint64_t squash_after_seq_num);
+    void squashAfter(ThreadID tid, DynInstPtr &head_inst);
 
     /** Handles processing an interrupt. */
     void handleInterrupt();
@@ -372,6 +398,15 @@ class DefaultCommit
     /** Records if a thread has to squash this cycle due to an XC write. */
     bool tcSquash[Impl::MaxThreads];
 
+    /**
+     * Instruction passed to squashAfter().
+     *
+     * The squash after implementation needs to buffer the instruction
+     * that caused a squash since this needs to be passed to the fetch
+     * stage once squashing starts.
+     */
+    DynInstPtr squashAfterInst[Impl::MaxThreads];
+
     /** Priority List used for Commit Policy */
     std::list<ThreadID> priority_list;