/** PC of this instruction. */
     Addr PC;
 
+  protected:
     /** Next non-speculative PC.  It is not filled in at fetch, but rather
      *  once the target of the branch is truly known (either decode or
      *  execute).
     /** If this is a branch that was predicted taken */
     bool predTaken;
 
+  public:
+
     /** Count of total number of dynamic instructions. */
     static int instcount;
 
     /** Returns the next NPC.  This could be the speculative next NPC if it is
      *  called prior to the actual branch target being calculated.
      */
-    Addr readNextNPC() { return nextNPC; }
+    Addr readNextNPC()
+    {
+#if ISA_HAS_DELAY_SLOT
+        return nextNPC;
+#else
+        return nextPC + sizeof(TheISA::MachInst);
+#endif
+    }
 
     /** Set the predicted target of this current instruction. */
     void setPredTarg(Addr predicted_PC, Addr predicted_NPC)
     /** Returns whether the instruction mispredicted. */
     bool mispredicted()
     {
-        return predPC != nextPC || predNPC != nextNPC;
+        return readPredPC() != readNextPC() ||
+            readPredNPC() != readNextNPC();
     }
 
     //
 
 
     virtual uint64_t readNextNPC()
     {
-        panic("Alpha has no NextNPC!");
-        return 0;
+        return this->readNextPC() + sizeof(TheISA::MachInst);
     }
 
     virtual void setNextNPC(uint64_t val)
 
     //Set PC/NPC/NNPC
     setPC(src_tc->readPC(), tid);
     setNextPC(src_tc->readNextPC(), tid);
-#if ISA_HAS_DELAY_SLOT
     setNextNPC(src_tc->readNextNPC(), tid);
-#endif
 
     src_tc->setStatus(ThreadContext::Active);
 
 
 
         uint64_t readNextNPC()
         {
-            return 0;
+#if ISA_HAS_DELAY_SLOT
+            panic("Ozone needs to support nextNPC");
+#else
+            return thread->nextPC + sizeof(TheISA::MachInst);
+#endif
         }
 
         void setNextNPC(uint64_t val)
-        { }
+        {
+#if ISA_HAS_DELAY_SLOT
+            panic("Ozone needs to support nextNPC");
+#endif
+        }
 
       public:
         // ISA stuff: