Add UI and C++/Python API to time travel to a given timestamp with custom icon (#848)

Author: Copilot

api/python/debuggercontroller.py

@@ -494,6 +494,62 @@ def _notify(event: dbgcore.BNDebuggerEvent, callback: DebuggerEventCallback) ->
             binaryninja.log_error(traceback.format_exc())
 
 
+class TTDPosition:
+    """
+    TTDPosition represents a position in a time travel debugging trace.
+    
+    It has the following fields:
+    
+    * ``sequence``: the sequence number (as hex string or int)
+    * ``step``: the step number within the sequence (as hex string or int)
+    """
+    
+    def __init__(self, sequence, step):
+        if isinstance(sequence, str):
+            self.sequence = int(sequence, 16)
+        else:
+            self.sequence = int(sequence)
+            
+        if isinstance(step, str):
+            self.step = int(step, 16)
+        else:
+            self.step = int(step)
+    
+    def __eq__(self, other):
+        if not isinstance(other, self.__class__):
+            return NotImplemented
+        return self.sequence == other.sequence and self.step == other.step
+    
+    def __ne__(self, other):
+        if not isinstance(other, self.__class__):
+            return NotImplemented
+        return not (self == other)
+    
+    def __hash__(self):
+        return hash((self.sequence, self.step))
+    
+    def __repr__(self):
+        return f"<TTDPosition: {self.sequence:x}:{self.step:x}>"
+    
+    def __str__(self):
+        return f"{self.sequence:x}:{self.step:x}"
+    
+    @classmethod
+    def from_string(cls, timestamp_str):
+        """
+        Create a TTDPosition from a string in format "sequence:step"
+        Both sequence and step can be in hex or decimal format.
+        """
+        if ':' not in timestamp_str:
+            raise ValueError("Timestamp must be in format 'sequence:step'")
+        
+        parts = timestamp_str.strip().split(':')
+        if len(parts) != 2:
+            raise ValueError("Timestamp must be in format 'sequence:step'")
+        
+        return cls(parts[0], parts[1])
+
+
 class DebuggerController:
     """
     The ``DebuggerController`` object is the core of the debugger. Most debugger operations can be performed on it.
@@ -1636,6 +1692,87 @@ def is_first_launch(self):
     def is_ttd(self):
         return dbgcore.BNDebuggerIsTTD(self.handle)
 
+    @property
+    def current_ttd_position(self):
+        """
+        Get the current position in the TTD trace.
+        
+        Returns:
+            TTDPosition: Current position, or None if not in TTD mode
+        """
+        if not self.is_ttd:
+            return None
+        
+        pos = dbgcore.BNDebuggerGetCurrentTTDPosition(self.handle)
+        return TTDPosition(pos.sequence, pos.step)
+
+    @current_ttd_position.setter
+    def current_ttd_position(self, position):
+        """
+        Navigate to a specific position in the TTD trace.
+        
+        Args:
+            position: TTDPosition object or string in format "sequence:step"
+        """
+        if not self.is_ttd:
+            raise RuntimeError("TTD is not active")
+        
+        if isinstance(position, str):
+            position = TTDPosition.from_string(position)
+        elif not isinstance(position, TTDPosition):
+            raise TypeError("Position must be TTDPosition object or string")
+        
+        # Create the C structure
+        pos = dbgcore.BNDebuggerTTDPosition()
+        pos.sequence = position.sequence
+        pos.step = position.step
+        
+        success = dbgcore.BNDebuggerSetTTDPosition(self.handle, pos)
+        if not success:
+            raise RuntimeError("Failed to navigate to the specified TTD position")
+
+    def set_ttd_position(self, position):
+        """
+        Navigate to a specific position in the TTD trace.
+        
+        Args:
+            position: TTDPosition object or string in format "sequence:step"
+            
+        Returns:
+            bool: True if navigation succeeded, False otherwise
+        """
+        if not self.is_ttd:
+            return False
+        
+        if isinstance(position, str):
+            position = TTDPosition.from_string(position)
+        elif not isinstance(position, TTDPosition):
+            raise TypeError("Position must be TTDPosition object or string")
+        
+        # Create the C structure
+        pos = dbgcore.BNDebuggerTTDPosition()
+        pos.sequence = position.sequence
+        pos.step = position.step
+        
+        return dbgcore.BNDebuggerSetTTDPosition(self.handle, pos)
+
+    def navigate_to_timestamp(self, timestamp_str):
+        """
+        Convenience method to navigate to a timestamp string.
+        
+        Args:
+            timestamp_str: String in format "sequence:step" (hex or decimal)
+            
+        Returns:
+            bool: True if navigation succeeded, False otherwise
+        """
+        try:
+            position = TTDPosition.from_string(timestamp_str)
+            return self.set_ttd_position(position)
+        except ValueError as e:
+            binaryninja.log_error(f"Invalid timestamp format: {e}")
+            return False
+
     def __del__(self):
         if dbgcore is not None:
             dbgcore.BNDebuggerFreeController(self.handle)

core/adapters/dbgengttdadapter.cpp

@@ -379,75 +379,85 @@ TTDPosition DbgEngTTDAdapter::GetCurrentTTDPosition()
 		return position;
 	}
 
-	// Use data model API to get current TTD position
-	std::string output = EvaluateDataModelExpression("@$cursession.TTD.Position");
+	// Always use the !position command to retrieve the current timestamp
+	std::string output = InvokeBackendCommand("!position");
 
-	if (!output.empty() && output != "complex_result")
+	if (!output.empty())
 	{
-		// Parse the position output (format like "1A0:12F")
-		size_t colonPos = output.find(':');
-		if (colonPos != std::string::npos)
+		// Parse the position output (format like "Time Travel Position: 602C:0")
+		size_t prefixPos = output.find("Time Travel Position:");
+		if (prefixPos != std::string::npos)
 		{
-			try 
+			// Find the position data after the prefix
+			size_t dataStart = prefixPos + strlen("Time Travel Position:");
+			std::string positionData = output.substr(dataStart);
+			
+			// Find the colon in the position data
+			size_t colonPos = positionData.find(':');
+			if (colonPos != std::string::npos)
 			{
-				std::string seqStr = output.substr(0, colonPos);
-				std::string stepStr = output.substr(colonPos + 1);
-				
-				// Remove any non-hex characters
-				seqStr.erase(std::remove_if(seqStr.begin(), seqStr.end(), 
-					[](char c) { return !std::isxdigit(c); }), seqStr.end());
-				stepStr.erase(std::remove_if(stepStr.begin(), stepStr.end(), 
-					[](char c) { return !std::isxdigit(c); }), stepStr.end());
-				
-				if (!seqStr.empty() && !stepStr.empty())
+				try 
 				{
-					position.sequence = std::stoull(seqStr, nullptr, 16);
-					position.step = std::stoull(stepStr, nullptr, 16);
+					std::string seqStr = positionData.substr(0, colonPos);
+					std::string stepStr = positionData.substr(colonPos + 1);
+					
+					// Remove any non-hex characters
+					seqStr.erase(std::remove_if(seqStr.begin(), seqStr.end(), 
+						[](char c) { return !std::isxdigit(c); }), seqStr.end());
+					stepStr.erase(std::remove_if(stepStr.begin(), stepStr.end(), 
+						[](char c) { return !std::isxdigit(c); }), stepStr.end());
+					
+					if (!seqStr.empty() && !stepStr.empty())
+					{
+						position.sequence = std::stoull(seqStr, nullptr, 16);
+						position.step = std::stoull(stepStr, nullptr, 16);
+					}
+				}
+				catch (const std::exception& e)
+				{
+					LogError("Failed to parse TTD position: %s", e.what());
 				}
-			}
-			catch (const std::exception& e)
-			{
-				LogError("Failed to parse TTD position: %s", e.what());
 			}
 		}
-	}
-	else
-	{
-		// Fallback to command interface if data model doesn't work
-		LogWarn("Data model evaluation failed, falling back to command interface");
-		std::string output = InvokeBackendCommand("!position");
-		
-		// Parse the position output (format like "1A0:12F")
-		size_t colonPos = output.find(':');
-		if (colonPos != std::string::npos)
+		else
 		{
-			try 
+			// Fallback: try to find a simple "XXXX:Y" pattern in the output
+			size_t colonPos = output.find(':');
+			if (colonPos != std::string::npos)
 			{
-				std::string seqStr = output.substr(0, colonPos);
-				std::string stepStr = output.substr(colonPos + 1);
-				
-				// Remove any non-hex characters
-				seqStr.erase(std::remove_if(seqStr.begin(), seqStr.end(), 
-					[](char c) { return !std::isxdigit(c); }), seqStr.end());
-				stepStr.erase(std::remove_if(stepStr.begin(), stepStr.end(), 
-					[](char c) { return !std::isxdigit(c); }), stepStr.end());
-				
-				if (!seqStr.empty() && !stepStr.empty())
+				try 
 				{
-					position.sequence = std::stoull(seqStr, nullptr, 16);
-					position.step = std::stoull(stepStr, nullptr, 16);
+					// Look backwards from colon to find start of hex sequence
+					size_t seqStart = colonPos;
+					while (seqStart > 0 && std::isxdigit(output[seqStart - 1]))
+						seqStart--;
+					
+					// Look forwards from colon to find end of hex step
+					size_t stepEnd = colonPos + 1;
+					while (stepEnd < output.length() && std::isxdigit(output[stepEnd]))
+						stepEnd++;
+					
+					if (seqStart < colonPos && stepEnd > colonPos + 1)
+					{
+						std::string seqStr = output.substr(seqStart, colonPos - seqStart);
+						std::string stepStr = output.substr(colonPos + 1, stepEnd - colonPos - 1);
+						
+						if (!seqStr.empty() && !stepStr.empty())
+						{
+							position.sequence = std::stoull(seqStr, nullptr, 16);
+							position.step = std::stoull(stepStr, nullptr, 16);
+						}
+					}
+				}
+				catch (const std::exception& e)
+				{
+					LogError("Failed to parse TTD position from fallback parsing: %s", e.what());
 				}
-			}
-			catch (const std::exception& e)
-			{
-				LogError("Failed to parse TTD position: %s", e.what());
 			}
 		}
 	}
 
 	return position;
-	
-	return position;
 }
 
 bool DbgEngTTDAdapter::SetTTDPosition(const TTDPosition& position)

debuggerui.qrc

@@ -24,5 +24,6 @@
         <file alias="stop">icons/stop.png</file>
         <file alias="ttd-memory">icons/ttd-memory.png</file>
         <file alias="ttd-calls">icons/ttd-calls.png</file>
+        <file alias="ttd-timestamp">icons/ttd-timestamp.png</file>
     </qresource>
 </RCC>

icons/ttd-timestamp.png

@@ -16,6 +16,7 @@ limitations under the License.
 
 #include "controlswidget.h"
 #include "adaptersettings.h"
+#include "timestampnavigationdialog.h"
 #include <QPixmap>
 #include <QInputDialog>
 #include <QMessageBox>
@@ -134,6 +135,11 @@ DebugControlsWidget::DebugControlsWidget(QWidget* parent, const std::string name
 		performStepReturnReverse();
 	});
 	m_actionStepReturnBack->setToolTip(getToolTip("Step Return Backwards"));
+
+	m_actionTimestampNavigation = addAction(getColoredIcon(":/debugger/ttd-timestamp", cyan), "Navigate to Timestamp", [this]() {
+		performTimestampNavigation();
+	});
+	m_actionTimestampNavigation->setToolTip(getToolTip("Navigate to TTD Timestamp..."));
 	updateButtons();
 }
 
@@ -507,6 +513,8 @@ void DebugControlsWidget::setReverseSteppingEnabled(bool enabled)
 	m_actionStepOverBack->setVisible(enabled);
 	m_actionStepReturnBack->setEnabled(enabled);
 	m_actionStepReturnBack->setVisible(enabled);
+	m_actionTimestampNavigation->setEnabled(enabled);
+	m_actionTimestampNavigation->setVisible(enabled);
 }
 
 
@@ -566,3 +574,16 @@ void DebugControlsWidget::updateButtons()
 		m_actionGoBack->setVisible(m_controller->IsTTD());
 	}
 }
+
+
+void DebugControlsWidget::performTimestampNavigation()
+{
+	if (!m_controller->IsTTD())
+	{
+		QMessageBox::warning(this, "Error", "Time travel debugging is not active.");
+		return;
+	}
+
+	auto* dialog = new TimestampNavigationDialog(this, m_controller);
+	dialog->show();
+}

ui/controlswidget.cpp

@@ -53,6 +53,7 @@ class DebugControlsWidget : public QToolBar
 
 	QAction* m_actionSettings;
 	QAction* m_actionToggleBreakpoint;
+	QAction* m_actionTimestampNavigation;
 
 	bool canExec();
 	bool canConnect();
@@ -90,4 +91,5 @@ public Q_SLOTS:
 
 	void performSettings();
 	void toggleBreakpoint();
+	void performTimestampNavigation();
 };