diff --git a/cheriot/BUILD b/cheriot/BUILD
index 8feb88d..3e2156a 100644
--- a/cheriot/BUILD
+++ b/cheriot/BUILD
@@ -591,6 +591,7 @@
         "@com_google_mpact-sim//mpact/sim/generic:core",
         "@com_google_mpact-sim//mpact/sim/generic:core_debug_interface",
         "@com_google_mpact-sim//mpact/sim/generic:counters",
+        "@com_google_mpact-sim//mpact/sim/generic:debug_command_shell_interface",
         "@com_google_mpact-sim//mpact/sim/generic:instruction",
         "@com_google_mpact-sim//mpact/sim/proto:component_data_cc_proto",
         "@com_google_mpact-sim//mpact/sim/util/memory",
@@ -708,6 +709,7 @@
         "@com_google_mpact-riscv//riscv:stoull_wrapper",
         "@com_google_mpact-sim//mpact/sim/generic:core",
         "@com_google_mpact-sim//mpact/sim/generic:core_debug_interface",
+        "@com_google_mpact-sim//mpact/sim/generic:debug_command_shell_interface",
         "@com_google_mpact-sim//mpact/sim/generic:type_helpers",
         "@com_google_mpact-sim//mpact/sim/proto:component_data_cc_proto",
         "@com_google_mpact-sim//mpact/sim/util/memory",
diff --git a/cheriot/cheriot_cli_forwarder.cc b/cheriot/cheriot_cli_forwarder.cc
index 633f763..6c5075b 100644
--- a/cheriot/cheriot_cli_forwarder.cc
+++ b/cheriot/cheriot_cli_forwarder.cc
@@ -80,6 +80,15 @@
 
 absl::Status CheriotCLIForwarder::Halt() { return cheriot_cli_top_->CLIHalt(); }
 
+absl::Status CheriotCLIForwarder::Halt(HaltReason halt_reason) {
+  cheriot_cli_top_->CLIRequestHalt(halt_reason, nullptr);
+  return absl::OkStatus();
+}
+
+absl::Status CheriotCLIForwarder::Halt(HaltReasonValueType halt_reason) {
+  cheriot_cli_top_->CLIRequestHalt(halt_reason, nullptr);
+  return absl::OkStatus();
+}
 absl::StatusOr<int> CheriotCLIForwarder::Step(int num) {
   return cheriot_cli_top_->CLIStep(num);
 }
diff --git a/cheriot/cheriot_cli_forwarder.h b/cheriot/cheriot_cli_forwarder.h
index a07386a..3da7fb6 100644
--- a/cheriot/cheriot_cli_forwarder.h
+++ b/cheriot/cheriot_cli_forwarder.h
@@ -71,6 +71,8 @@
   void SetBreakOnControlFlowChange(bool value) override;
   // Request that core stop running.
   absl::Status Halt() override;
+  absl::Status Halt(HaltReason halt_reason) override;
+  absl::Status Halt(HaltReasonValueType halt_reason) override;
   // Step the core by num instructions.
   absl::StatusOr<int> Step(int num) override;
   // Allow the core to free-run. The loop to run the instructions should be
diff --git a/cheriot/cheriot_renode.cc b/cheriot/cheriot_renode.cc
index aa417f8..88d2ea1 100644
--- a/cheriot/cheriot_renode.cc
+++ b/cheriot/cheriot_renode.cc
@@ -426,7 +426,7 @@
         cmd_shell_, cheriot_top_, mem_profiler_);
     cmd_shell_->AddCore(
         {static_cast<CheriotDebugInterface *>(cheriot_cli_forwarder_),
-         [this]() { return program_loader_; }});
+         [this]() { return program_loader_; }, cheriot_state_});
     cmd_shell_->AddCommand(
         instrumentation_control_->Usage(),
         absl::bind_front(&CheriotInstrumentationControl::PerformShellCommand,
diff --git a/cheriot/cheriot_state.cc b/cheriot/cheriot_state.cc
index e0c194d..685e6d0 100644
--- a/cheriot/cheriot_state.cc
+++ b/cheriot/cheriot_state.cc
@@ -655,9 +655,28 @@
   set_branch(true);
   // TODO(torerik): set next pc
   mstatus_->Submit();
+  // Set up interrupt info before incrementing the interrupt counter. That way
+  // any code that is triggered by the interrupt counter will see the updated
+  // interrupt info.
+  InterruptInfo info;
+  info.is_interrupt = is_interrupt;
+  info.cause = mcause_->GetUint32();
+  info.tval = mtval_->GetUint32();
+  info.epc = epc;
+  interrupt_info_list_.push_back(info);
+
   counter_interrupts_taken_.Increment(1);
 }
 
+// Called upon returning from an interrupt or exception.
+void CheriotState::SignalReturnFromInterrupt() {
+  // First increment the interrupt return counter. Then pop the interrupt info.
+  // This way any code that is triggered by the interrupt return counter will
+  // be able to access the interrupt info.
+  counter_interrupt_returns_.Increment(1);
+  interrupt_info_list_.pop_back();
+}
+
 // CheckForInterrupt is called whenever any relevant bits in the interrupt
 // enable and set bits are changed. It should always be scheduled to execute
 // from the function_delay_line, that way it is executed after an instruction
diff --git a/cheriot/cheriot_state.h b/cheriot/cheriot_state.h
index b24f5e3..6045039 100644
--- a/cheriot/cheriot_state.h
+++ b/cheriot/cheriot_state.h
@@ -19,6 +19,7 @@
 
 #include <any>
 #include <cstdint>
+#include <deque>
 #include <string>
 #include <string_view>
 #include <utility>
@@ -157,6 +158,15 @@
 
 using ::mpact::sim::generic::operator*;  // NOLINT: used below (clang error).
 
+// Struct to track interrupt/trap information.
+struct InterruptInfo {
+  bool is_interrupt;
+  uint32_t cause;
+  uint32_t tval;
+  uint32_t epc;
+};
+using InterruptInfoList = std::deque<InterruptInfo>;
+
 class CheriotState : public generic::ArchState {
  public:
   static int constexpr kCapRegQueueSizeMask = 0x11;
@@ -290,7 +300,7 @@
   // Indicates that the program has returned from handling an interrupt. This
   // decrements the interrupt handler depth and should be called by the
   // implementations of mret, sret, and uret.
-  void SignalReturnFromInterrupt() { counter_interrupt_returns_.Increment(1); }
+  void SignalReturnFromInterrupt();
 
   // Returns the depth of the interrupt handler currently being executed, or
   // zero if no interrupt handler is being executed.
@@ -399,7 +409,9 @@
   CheriotRegister *temp_reg() { return temp_reg_; }
   RiscVCsrInterface *mcause() { return mcause_; }
   RiscVCheri32PcSourceOperand *pc_src_operand() { return pc_src_operand_; }
-
+  const InterruptInfoList &interrupt_info_list() const {
+    return interrupt_info_list_;
+  }
   uint64_t revocation_mem_base() const { return revocation_mem_base_; }
   uint64_t revocation_ram_base() const { return revocation_ram_base_; }
 
@@ -451,6 +463,7 @@
   SimpleCounter<int64_t> counter_interrupts_taken_;
   SimpleCounter<int64_t> counter_interrupt_returns_;
   InterruptCode available_interrupt_code_ = InterruptCode::kNone;
+  InterruptInfoList interrupt_info_list_;
   // By default, execute in machine mode.
   PrivilegeMode privilege_mode_ = PrivilegeMode::kMachine;
   // Handles to frequently used CSRs.
diff --git a/cheriot/cheriot_top.cc b/cheriot/cheriot_top.cc
index 14d1cbf..6df56ad 100644
--- a/cheriot/cheriot_top.cc
+++ b/cheriot/cheriot_top.cc
@@ -216,6 +216,16 @@
   return absl::OkStatus();
 }
 
+absl::Status CheriotTop::Halt(HaltReason halt_reason) {
+  RequestHalt(halt_reason, nullptr);
+  return absl::OkStatus();
+}
+
+absl::Status CheriotTop::Halt(HaltReasonValueType halt_reason) {
+  RequestHalt(halt_reason, nullptr);
+  return absl::OkStatus();
+}
+
 absl::Status CheriotTop::StepPastBreakpoint() {
   uint64_t pc = state_->pc_operand()->AsUint64(0);
   // Disable the breakpoint.
diff --git a/cheriot/cheriot_top.h b/cheriot/cheriot_top.h
index 660d188..655bc94 100644
--- a/cheriot/cheriot_top.h
+++ b/cheriot/cheriot_top.h
@@ -73,6 +73,8 @@
 
   // Methods inherited from CoreDebugInterface.
   absl::Status Halt() override;
+  absl::Status Halt(HaltReason halt_reason) override;
+  absl::Status Halt(HaltReasonValueType halt_reason) override;
   absl::StatusOr<int> Step(int num) override;
   absl::Status Run() override;
   absl::Status Wait() override;
diff --git a/cheriot/debug_command_shell.cc b/cheriot/debug_command_shell.cc
index e1ea869..927bc34 100644
--- a/cheriot/debug_command_shell.cc
+++ b/cheriot/debug_command_shell.cc
@@ -35,6 +35,7 @@
 #include "absl/strings/string_view.h"
 #include "cheriot/cheriot_debug_interface.h"
 #include "cheriot/cheriot_register.h"
+#include "cheriot/cheriot_state.h"
 #include "cheriot/cheriot_top.h"
 #include "cheriot/riscv_cheriot_enums.h"
 #include "cheriot/riscv_cheriot_register_aliases.h"
@@ -56,56 +57,37 @@
 
 DebugCommandShell::InterruptListener::InterruptListener(CoreAccess *core_access)
     : core_access_(core_access),
-      top_(static_cast<CheriotTop *>(core_access->debug_interface)),
+      state_(static_cast<CheriotState *>(core_access_->state)),
+      dbg_if_(static_cast<CheriotTop *>(core_access->debug_interface)),
       taken_listener_(
           absl::bind_front(&InterruptListener::SetTakenValue, this)),
       return_listener_(
           absl::bind_front(&InterruptListener::SetReturnValue, this)) {
-  top_->state()->counter_interrupts_taken()->AddListener(&taken_listener_);
-  top_->state()->counter_interrupt_returns()->AddListener(&return_listener_);
+  state_->counter_interrupts_taken()->AddListener(&taken_listener_);
+  state_->counter_interrupt_returns()->AddListener(&return_listener_);
 }
 
 void DebugCommandShell::InterruptListener::SetReturnValue(int64_t value) {
-  if (interrupt_info_list_.empty()) {
+  auto &interrupt_info_list = state_->interrupt_info_list();
+  if (interrupt_info_list.empty()) {
     LOG(ERROR) << "Interrupt stack is empty";
     return;
   }
-  auto info = interrupt_info_list_.front();
-  interrupt_info_list_.pop_front();
+  auto info = interrupt_info_list.back();
   // If breakpoints are enabled, then request a halt of the appropriate type.
   if (info.is_interrupt && interrupts_enabled_)
-    top_->RequestHalt(kInterruptReturn, nullptr);
+    (void)dbg_if_->Halt(kInterruptReturn);
   if (!info.is_interrupt && exceptions_enabled_)
-    top_->RequestHalt(kExceptionReturn, nullptr);
+    (void)dbg_if_->Halt(kExceptionReturn);
 }
 
 void DebugCommandShell::InterruptListener::SetTakenValue(int64_t value) {
-  InterruptInfo info;
-  bool ok = true;
-  // Read the values of the interrupt registers.
-  auto res = core_access_->debug_interface->ReadRegister("mcause");
-  ok &= res.ok();
-  if (ok) info.cause = res.value();
-
-  res = core_access_->debug_interface->ReadRegister("mtval");
-  ok &= res.ok();
-  if (ok) info.tval = res.value();
-
-  res = core_access_->debug_interface->ReadRegister("mepcc");
-  ok &= res.ok();
-  if (ok) info.epc = res.value();
-
-  if (!ok) {
-    LOG(ERROR) << "Failed to read interrupt registers";
-    return;
-  }
-  info.is_interrupt = (info.cause & 0x8000'0000u) != 0;
+  InterruptInfo info = state_->interrupt_info_list().back();
   // If breakpoints are enabled, the request a halt of the appropriate type.
   if (info.is_interrupt && interrupts_enabled_)
-    top_->RequestHalt(kInterruptTaken, nullptr);
+    (void)dbg_if_->Halt(kInterruptTaken);
   if (!info.is_interrupt && exceptions_enabled_)
-    top_->RequestHalt(kExceptionTaken, nullptr);
-  interrupt_info_list_.push_front(info);
+    (void)dbg_if_->Halt(kExceptionTaken);
 }
 
 // The constructor initializes all the regular expressions and the help string.
@@ -332,8 +314,9 @@
       }
       absl::StrAppend(&prompt, "\n");
     }
-    auto &info_list =
-        interrupt_listeners_[current_core_]->interrupt_info_list();
+    auto cheriot_state =
+        static_cast<CheriotState *>(core_access_[current_core_].state);
+    auto &info_list = cheriot_state->interrupt_info_list();
     int count = 0;
     for (auto iter = info_list.rbegin(); iter != info_list.rend(); ++iter) {
       auto const &info = *iter;
diff --git a/cheriot/debug_command_shell.h b/cheriot/debug_command_shell.h
index 71fc7b0..b58b1fe 100644
--- a/cheriot/debug_command_shell.h
+++ b/cheriot/debug_command_shell.h
@@ -32,7 +32,8 @@
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
 #include "absl/strings/string_view.h"
-#include "cheriot/cheriot_top.h"
+#include "cheriot/cheriot_debug_interface.h"
+#include "cheriot/cheriot_state.h"
 #include "mpact/sim/generic/core_debug_interface.h"
 #include "mpact/sim/generic/counters_base.h"
 #include "mpact/sim/generic/debug_command_shell_interface.h"
@@ -88,14 +89,6 @@
     bool is_enabled;
   };
 
-  // Struct to track interrupt/trap information.
-  struct InterruptInfo {
-    bool is_interrupt;
-    uint32_t cause;
-    uint32_t tval;
-    uint32_t epc;
-  };
-
   // The interrupt listener class is used to track interrupts/exceptions and
   // returns from interrupts/exceptions, so that breakpoints can be set on these
   // events.
@@ -112,7 +105,6 @@
       absl::AnyInvocable<void(int64_t)> callback_;
     };
 
-    using InterruptInfoList = std::deque<InterruptInfo>;
     static constexpr uint32_t kInterruptTaken =
         *HaltReason::kUserSpecifiedMin + 1;
     static constexpr uint32_t kInterruptReturn =
@@ -128,19 +120,15 @@
     bool AreExceptionsEnabled() const { return exceptions_enabled_; }
     bool AreInterruptsEnabled() const { return interrupts_enabled_; }
 
-    const InterruptInfoList &interrupt_info_list() const {
-      return interrupt_info_list_;
-    }
-
    private:
     void SetReturnValue(int64_t value);
     void SetTakenValue(int64_t value);
 
     CoreAccess *core_access_;
-    CheriotTop *top_;
+    CheriotState *state_ = nullptr;
+    CheriotDebugInterface *dbg_if_ = nullptr;
     bool interrupts_enabled_ = false;
     bool exceptions_enabled_ = false;
-    InterruptInfoList interrupt_info_list_;
     Listener taken_listener_;
     Listener return_listener_;
   };
diff --git a/cheriot/mpact_cheriot.cc b/cheriot/mpact_cheriot.cc
index a15cfee..a24abce 100644
--- a/cheriot/mpact_cheriot.cc
+++ b/cheriot/mpact_cheriot.cc
@@ -464,7 +464,8 @@
   CheriotInstrumentationControl *cheriot_instrumentation_control = nullptr;
   if (interactive) {
     mpact::sim::cheriot::DebugCommandShell cmd_shell;
-    cmd_shell.AddCore({&cheriot_top, [&elf_loader]() { return &elf_loader; }});
+    cmd_shell.AddCore({&cheriot_top, [&elf_loader]() { return &elf_loader; },
+                       &cheriot_state});
     cheriot_instrumentation_control = new CheriotInstrumentationControl(
         &cmd_shell, &cheriot_top, memory_use_profiler);
     // Add custom command to interactive debug command shell.