Extend ctrace-run support and improve trace capture handling

pyocd/core/soc_target.py

@@ -326,10 +326,10 @@ def trace_start(self):
     def trace_stop(self):
         self.call_delegate('trace_stop', target=self, mode=0)
 
-    def trace_capture(self):
+    def trace_capture(self, core: Optional[CoreTarget] = None):
         self.call_delegate('trace_capture', target=self, mode=0)
 
-    def trace_flush(self):
+    def trace_flush(self, core: Optional[CoreTarget] = None):
         self.call_delegate('trace_flush', target=self, mode=0)
 
     def add_target_command_groups(self, command_set: CommandSet):

pyocd/coresight/coresight_target.py

@@ -32,6 +32,7 @@
 from ..target.pack.flm_region_builder import FlmFlashRegionBuilder
 
 if TYPE_CHECKING:
+    from ..core.core_target import CoreTarget
     from ..core.session import Session
     from .ap import (APAddressBase, AccessPort)
     from ..debug.svd.model import SVDDevice
@@ -416,24 +417,36 @@ def _run_trace_sequence(self, name: str) -> None:
             if seq.name == name:
                 delegate.run_sequence(name, pname=seq.pname)
 
-    def trace_capture(self) -> None:
-        changed = False
-        if self.session.ctrace_run is not None:
-            changed = self.session.ctrace_run.apply(self)
+    def trace_capture(self, core: Optional["CoreTarget"] = None) -> None:
+        pname = core.node_name if core else None
 
         result = self.call_delegate('trace_capture', target=self, mode=0)
-        if not result and self.has_debug_sequence('TraceCapture'):
+        if not result and self.has_debug_sequence('TraceCapture', pname=pname):
             assert self.debug_sequence_delegate
             if self.debug_sequence_delegate.trace_setup == TraceSetup.FULL:
-                self.debug_sequence_delegate.run_sequence('TraceCapture')
-        self.session.notify(self.session.Event.TRACE_DATA_CAPTURE, self.session, changed)
+                self.debug_sequence_delegate.run_sequence('TraceCapture', pname=pname)
+
+        if (ctrace_run := self.session.ctrace_run) is not None:
+            with ctrace_run.update():
+                changed = ctrace_run.load()
+                if changed:
+                    ctrace_run.apply_disable(self)
+                self.session.notify(self.session.Event.TRACE_DATA_CAPTURE, self.session, ctrace_run.reloaded)
+                if changed:
+                    ctrace_run.apply_refs(self)
+                ctrace_run.itm_force_sync(core if core is not None else self.primary_core)
+        else:
+            self.session.notify(self.session.Event.TRACE_DATA_CAPTURE, self.session, False)
+
+    def trace_flush(self, core: Optional["CoreTarget"] = None) -> None:
+        pname = core.node_name if core else None
 
-    def trace_flush(self) -> None:
         result = self.call_delegate('trace_flush', target=self, mode=0)
-        if not result and self.has_debug_sequence('TraceFlush'):
+        if not result and self.has_debug_sequence('TraceFlush', pname=pname):
             assert self.debug_sequence_delegate
             if self.debug_sequence_delegate.trace_setup == TraceSetup.FULL:
-                self.debug_sequence_delegate.run_sequence('TraceFlush')
+                self.debug_sequence_delegate.run_sequence('TraceFlush', pname=pname)
+
         self.session.notify(self.session.Event.TRACE_DATA_FLUSH, self.session)
 
     def write_trace_buffer(self, name: str, data: bytes) -> int:

pyocd/coresight/dwt.py

@@ -1,5 +1,5 @@
 # pyOCD debugger
-# Copyright (c) 2015-2019 Arm Limited
+# Copyright (c) 2015-2019,2026 Arm Limited
 # SPDX-License-Identifier: Apache-2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -55,6 +55,7 @@ class DWT(CoreSightComponent):
 
     DWT_CTRL_NUM_COMP_MASK = (0xF << 28)
     DWT_CTRL_NUM_COMP_SHIFT = 28
+    DWT_CTRL_NOCYCCNT_MASK = (1 << 25)
     DWT_CTRL_CYCEVTENA_MASK = (1 << 22)
     DWT_CTRL_FOLDEVTENA_MASK = (1 << 21)
     DWT_CTRL_LSUEVTENA_MASK = (1 << 20)
@@ -73,13 +74,13 @@ class DWT(CoreSightComponent):
     DWT_CTRL_CYCCNTENA_MASK = (1 << 0)
 
     WATCH_TYPE_TO_FUNCT = {
-                            Target.WatchpointType.READ: 5,
-                            Target.WatchpointType.WRITE: 6,
-                            Target.WatchpointType.READ_WRITE: 7,
-                            5: Target.WatchpointType.READ,
-                            6: Target.WatchpointType.WRITE,
-                            7: Target.WatchpointType.READ_WRITE,
-                            }
+        Target.WatchpointType.READ: 5,
+        Target.WatchpointType.WRITE: 6,
+        Target.WatchpointType.READ_WRITE: 7,
+        5: Target.WatchpointType.READ,
+        6: Target.WatchpointType.WRITE,
+        7: Target.WatchpointType.READ_WRITE,
+    }
 
     # Only sizes that are powers of 2 are supported
     # Breakpoint size = MASK**2
@@ -90,6 +91,7 @@ def __init__(self, ap, cmpid=None, addr=None):
         self.watchpoints = []
         self.watchpoint_used = 0
         self.dwt_configured = False
+        self._has_cycle_counter = False
 
     @property
     def watchpoint_count(self):
@@ -108,6 +110,7 @@ def init(self):
             self.ap.write_memory(DEMCR, demcr)
 
         dwt_ctrl = self.ap.read_memory(self.address + self.DWT_CTRL)
+        self._has_cycle_counter = not bool(dwt_ctrl & self.DWT_CTRL_NOCYCCNT_MASK)
         watchpoint_count = (dwt_ctrl & self.DWT_CTRL_NUM_COMP_MASK) >> self.DWT_CTRL_NUM_COMP_SHIFT
         LOG.info("%d hardware watchpoints", watchpoint_count)
         for i in range(watchpoint_count):
@@ -116,7 +119,10 @@ def init(self):
             self.ap.write_memory(comparatorAddress + self.DWT_FUNCTION_OFFSET, 0)
 
         # Enable cycle counter.
-        self.ap.write32(self.address + self.DWT_CTRL, self.DWT_CTRL_CYCCNTENA_MASK)
+        if self._has_cycle_counter:
+            self.ap.write32(self.address + self.DWT_CTRL, self.DWT_CTRL_CYCCNTENA_MASK)
+        else:
+            self.ap.write32(self.address + self.DWT_CTRL, 0x0)
         self.dwt_configured = True
 
     def find_watchpoint(self, addr, size, type):
@@ -184,6 +190,10 @@ def remove_all_watchpoints(self):
     def get_watchpoints(self):
         return [watch for watch in self.watchpoints if watch.func != 0]
 
+    @property
+    def has_cycle_counter(self) -> bool:
+        return self._has_cycle_counter
+
     @property
     def cycle_count(self):
         return self.ap.read32(self.address + self.DWT_CYCCNT)
@@ -205,20 +215,20 @@ class DWTv2(DWT):
 
     ## Map from watchpoint type to FUNCTIONn.MATCH field value.
     WATCH_TYPE_TO_FUNCT = {
-                            Target.WatchpointType.READ: 0b0110,
-                            Target.WatchpointType.WRITE: 0b0101,
-                            Target.WatchpointType.READ_WRITE: 0b0100,
-                            0b0110: Target.WatchpointType.READ,
-                            0b0101: Target.WatchpointType.WRITE,
-                            0b0100: Target.WatchpointType.READ_WRITE,
-                            }
+        Target.WatchpointType.READ: 0b0110,
+        Target.WatchpointType.WRITE: 0b0101,
+        Target.WatchpointType.READ_WRITE: 0b0100,
+        0b0110: Target.WatchpointType.READ,
+        0b0101: Target.WatchpointType.WRITE,
+        0b0100: Target.WatchpointType.READ_WRITE,
+    }
 
     ## Map from data access size to pre-shifted DATAVSIZE field value.
     DATAVSIZE_MAP = {
-                        1: (0 << 10),
-                        2: (1 << 10),
-                        4: (2 << 10),
-                    }
+        1: (0 << 10),
+        2: (1 << 10),
+        4: (2 << 10),
+    }
 
     def set_watchpoint(self, addr, size, type):
         """@brief Set a hardware watchpoint."""
@@ -254,6 +264,3 @@ def set_watchpoint(self, addr, size, type):
 
         LOG.error('No more watchpoints are available, dropped watchpoint at 0x%08x', addr)
         return False
-
-
-

pyocd/gdbserver/gdbserver.py

@@ -426,11 +426,11 @@ def __init__(self, session, core=None):
 
     def trace_flush(self) -> None:
         if self.board.target.trace_enabled:
-            self.board.target.trace_flush()
+            self.board.target.trace_flush(self.target)
 
     def trace_capture(self) -> None:
         if self.board.target.trace_enabled:
-            self.board.target.trace_capture()
+            self.board.target.trace_capture(self.target)
 
     def _init_remote_commands(self):
         """@brief Initialize the remote command processor infrastructure."""