feat: try to support callstack instead of calltrace for rr: for now

TODO: bugfixing and finish jumping

Author: alehander92

src/db-backend/src/db.rs

@@ -16,8 +16,8 @@ use crate::expr_loader::ExprLoader;
 use crate::lang::Lang;
 use crate::replay::Replay;
 use crate::task::{
-    Action, Breakpoint, Call, CallArg, CoreTrace, CtLoadLocalsArguments, Events, Location, ProgramEvent, RRTicks,
-    VariableWithRecord, NO_INDEX, NO_PATH, NO_POSITION,
+    Action, Breakpoint, Call, CallArg, CallLine, CoreTrace, CtLoadLocalsArguments, Events, Location, ProgramEvent,
+    RRTicks, VariableWithRecord, NO_INDEX, NO_PATH, NO_POSITION,
 };
 use crate::value::{Type, Value, ValueRecordWithType};
 
@@ -1215,6 +1215,11 @@ impl Replay for DbReplay {
         self.db.load_step_events(step_id, exact)
     }
 
+    fn load_callstack(&mut self) -> Result<Vec<CallLine>, Box<dyn Error>> {
+        warn!("load_callstack not implemented for db traces currently");
+        Ok(vec![])
+    }
+
     fn jump_to(&mut self, step_id: StepId) -> Result<bool, Box<dyn Error>> {
         self.step_id = step_id;
         Ok(true)
@@ -1301,6 +1306,12 @@ impl Replay for DbReplay {
         Ok(true)
     }
 
+    fn callstack_jump(&mut self, _depth: usize) -> Result<(), Box<dyn Error>> {
+        // TODO? for now used only for rr
+        warn!("callstack_jump not implemented for db replay currently");
+        Ok(())
+    }
+
     fn current_step_id(&mut self) -> StepId {
         self.step_id
     }

src/db-backend/src/handler.rs

@@ -28,11 +28,11 @@ use crate::task;
 use crate::task::{
     Action, Breakpoint, Call, CallArgsUpdateResults, CallLine, CallSearchArg, CalltraceLoadArgs,
     CalltraceNonExpandedKind, CollapseCallsArgs, CoreTrace, CtLoadFlowArguments, DbEventKind, FlowMode, FlowUpdate,
-    FrameInfo, FunctionLocation, HistoryResult, HistoryUpdate, Instruction, Instructions, LoadHistoryArg,
-    LoadStepLinesArg, LoadStepLinesUpdate, LocalStepJump, Location, MoveState, Notification, NotificationKind,
-    ProgramEvent, RRGDBStopSignal, RRTicks, RegisterEventsArg, RunTracepointsArg, SourceCallJumpTarget, SourceLocation,
-    StepArg, Stop, StopType, StringAndValueTuple, Task, TraceKind, TraceUpdate, TracepointId, TracepointResults,
-    UpdateTableArgs, Variable, NO_INDEX, NO_PATH, NO_POSITION, NO_STEP_ID,
+    FrameInfo, FunctionLocation, GlobalCallLineIndex, HistoryResult, HistoryUpdate, Instruction, Instructions,
+    LoadHistoryArg, LoadStepLinesArg, LoadStepLinesUpdate, LocalStepJump, Location, MoveState, Notification,
+    NotificationKind, ProgramEvent, RRGDBStopSignal, RRTicks, RegisterEventsArg, RunTracepointsArg,
+    SourceCallJumpTarget, SourceLocation, StepArg, Stop, StopType, StringAndValueTuple, Task, TraceKind, TraceUpdate,
+    TracepointId, TracepointResults, UpdateTableArgs, Variable, NO_INDEX, NO_PATH, NO_POSITION, NO_STEP_ID,
 };
 use crate::tracepoint_interpreter::TracepointInterpreter;
 use crate::value::{to_ct_value, Type, Value};
@@ -433,24 +433,39 @@ impl Handler {
         args: CalltraceLoadArgs,
     ) -> Result<(), Box<dyn Error>> {
         if self.trace_kind == TraceKind::RR {
-            warn!("load_calltrace_section not implemented for rr");
-            return Ok(());
-        }
-
-        let start_call_line_index = args.start_call_line_index;
-        let call_lines = self.load_local_calltrace(args)?;
-        let total_count = self.calc_total_calls();
-        let position = self.calltrace.calc_scroll_position();
-        let update = CallArgsUpdateResults::finished_update_call_lines(
-            call_lines,
-            start_call_line_index,
-            total_count,
-            position,
-            self.calltrace.depth_offset,
-        );
-        // self.return_task((task, VOID_RESULT.to_string()))?;
-        let raw_event = self.dap_client.updated_calltrace_event(&update)?;
-        self.send_dap(&raw_event)?;
+            // TODO: calltrace? eventually in the future
+            // for now callstack!
+
+            let start_call_line_index = GlobalCallLineIndex(0);
+            let callstack_lines = self.replay.load_callstack()?;
+            let total_count = callstack_lines.len();
+            let position = 0;
+            let update = CallArgsUpdateResults::finished_update_call_lines(
+                callstack_lines,
+                start_call_line_index,
+                total_count,
+                position,
+                self.calltrace.depth_offset,
+            );
+            let raw_event = self.dap_client.updated_calltrace_event(&update)?;
+            self.send_dap(&raw_event)?;
+            // warn!("load_calltrace_section not implemented for rr");
+        } else {
+            let start_call_line_index = args.start_call_line_index;
+            let call_lines = self.load_local_calltrace(args)?;
+            let total_count = self.calc_total_calls();
+            let position = self.calltrace.calc_scroll_position();
+            let update = CallArgsUpdateResults::finished_update_call_lines(
+                call_lines,
+                start_call_line_index,
+                total_count,
+                position,
+                self.calltrace.depth_offset,
+            );
+            // self.return_task((task, VOID_RESULT.to_string()))?;
+            let raw_event = self.dap_client.updated_calltrace_event(&update)?;
+            self.send_dap(&raw_event)?;
+        }
         Ok(())
     }
 
@@ -662,10 +677,18 @@ impl Handler {
     }
 
     pub fn calltrace_jump(&mut self, _req: dap::Request, location: Location) -> Result<(), Box<dyn Error>> {
-        let step_id = StepId(location.rr_ticks.0); // using this field
-                                                   // for compat with rr/gdb core support
-        self.replay.jump_to(step_id)?;
-        self.step_id = self.replay.current_step_id();
+        if self.trace_kind == TraceKind::DB {
+            let step_id = StepId(location.rr_ticks.0); // using this field
+                                                       // for compat with rr/gdb core support
+            self.replay.jump_to(step_id)?;
+            self.step_id = self.replay.current_step_id();
+        } else {
+            // TODO: eventually calltrace in the future
+            // for now support only callstack-mode
+            self.replay.callstack_jump(location.callstack_depth)?;
+            let _ = self.replay.load_location(&mut self.expr_loader)?;
+            self.step_id = self.replay.current_step_id();
+        }
         self.complete_move(false)?;
 
         Ok(())

src/db-backend/src/query.rs

@@ -20,5 +20,7 @@ pub enum CtRRQuery {
     DisableBreakpoints,
     JumpToCall { location: Location },
     LoadAllEvents,
+    LoadCallstack,
     EventJump { program_event: ProgramEvent },
+    CallstackJump { depth: usize },
 }

src/db-backend/src/replay.rs

@@ -4,7 +4,9 @@ use std::error::Error;
 use crate::db::DbRecordEvent;
 use crate::expr_loader::ExprLoader;
 use crate::lang::Lang;
-use crate::task::{Action, Breakpoint, CtLoadLocalsArguments, Events, Location, ProgramEvent, VariableWithRecord};
+use crate::task::{
+    Action, Breakpoint, CallLine, CtLoadLocalsArguments, Events, Location, ProgramEvent, VariableWithRecord,
+};
 use crate::value::ValueRecordWithType;
 
 pub trait Replay: std::fmt::Debug {
@@ -20,6 +22,8 @@ pub trait Replay: std::fmt::Debug {
     fn load_return_value(&mut self, lang: Lang) -> Result<ValueRecordWithType, Box<dyn Error>>;
 
     fn load_step_events(&mut self, step_id: StepId, exact: bool) -> Vec<DbRecordEvent>;
+    fn load_callstack(&mut self) -> Result<Vec<CallLine>, Box<dyn Error>>;
+
     fn jump_to(&mut self, step_id: StepId) -> Result<bool, Box<dyn Error>>;
     fn add_breakpoint(&mut self, path: &str, line: i64) -> Result<Breakpoint, Box<dyn Error>>;
     fn delete_breakpoint(&mut self, breakpoint: &Breakpoint) -> Result<bool, Box<dyn Error>>;
@@ -29,5 +33,7 @@ pub trait Replay: std::fmt::Debug {
     fn disable_breakpoints(&mut self) -> Result<(), Box<dyn Error>>;
     fn jump_to_call(&mut self, location: &Location) -> Result<Location, Box<dyn Error>>;
     fn event_jump(&mut self, event: &ProgramEvent) -> Result<bool, Box<dyn Error>>;
+    fn callstack_jump(&mut self, depth: usize) -> Result<(), Box<dyn Error>>;
+
     fn current_step_id(&mut self) -> StepId;
 }

src/db-backend/src/rr_dispatcher.rs

@@ -8,7 +8,7 @@ use std::process::{Child, Command, Stdio};
 use std::thread;
 use std::time::Duration;
 
-use log::{error, info};
+use log::{error, info, warn};
 use runtime_tracing::StepId;
 
 use crate::db::DbRecordEvent;
@@ -17,7 +17,9 @@ use crate::lang::Lang;
 use crate::paths::ct_rr_worker_socket_path;
 use crate::query::CtRRQuery;
 use crate::replay::Replay;
-use crate::task::{Action, Breakpoint, CtLoadLocalsArguments, Events, Location, ProgramEvent, VariableWithRecord};
+use crate::task::{
+    Action, Breakpoint, CallLine, CtLoadLocalsArguments, Events, Location, ProgramEvent, VariableWithRecord,
+};
 use crate::value::ValueRecordWithType;
 
 #[derive(Debug)]
@@ -243,9 +245,16 @@ impl Replay for RRDispatcher {
     fn load_step_events(&mut self, _step_id: StepId, _exact: bool) -> Vec<DbRecordEvent> {
         // TODO: maybe cache events directly in replay for now, and use the same logic for them as in Db?
         // or directly embed Db? or separate events in a separate EventList?
+        warn!("load_step_events not implemented for rr traces");
         vec![]
     }
 
+    fn load_callstack(&mut self) -> Result<Vec<CallLine>, Box<dyn Error>> {
+        self.ensure_active_stable()?;
+        let res = serde_json::from_str::<Vec<CallLine>>(&self.stable.run_query(CtRRQuery::LoadCallstack)?)?;
+        Ok(res)
+    }
+
     fn jump_to(&mut self, _step_id: StepId) -> Result<bool, Box<dyn Error>> {
         // TODO
         error!("TODO rr jump_to: for now run to entry");
@@ -318,6 +327,12 @@ impl Replay for RRDispatcher {
         )?)?)
     }
 
+    fn callstack_jump(&mut self, depth: usize) -> Result<(), Box<dyn Error>> {
+        self.ensure_active_stable()?;
+        self.stable.run_query(CtRRQuery::CallstackJump { depth })?;
+        Ok(())
+    }
+
     fn current_step_id(&mut self) -> StepId {
         // cache location or step_id and return
         // OR always load from worker

src/frontend/types.nim

@@ -733,6 +733,7 @@ type
     callValuePosition*: JsAssoc[cstring, float]
     width*: cstring
     resizeObserver*: ResizeObserver
+    isCalltrace*: bool
 
     debugger*:       DebuggerService
     service*:        CalltraceService

src/frontend/ui/calltrace.nim

@@ -28,8 +28,15 @@ when defined(ctInExtension):
     result = calltraceComponentForExtension
 
 proc calltraceJump(self: CalltraceComponent, location: types.Location) =
+  # if not self.supportCallstackOnly:
   self.api.emit(CtCalltraceJump, location)
   self.api.emit(InternalNewOperation, NewOperation(stableBusy: true, name: "calltrace-jump"))
+  # else:
+    # self.callstackJump(location.depth)
+
+# proc callstackJump(self: CalltraceComponent, depth: int) =
+#   self.api.emit(CtCallstackJump, location)
+#   self.api.emit(InternalNewOperation, NewOperation(stableBusy: true, name: "calltrace-jump"))
 
 proc isAtStart(self: CalltraceComponent): bool =
   self.startCallLineIndex < START_BUFFER
@@ -848,8 +855,22 @@ method onUpdatedCalltrace*(self: CalltraceComponent, results: CtUpdatedCalltrace
 
   self.redraw()
 
+# proc processStackFrame*(self: CalltraceComponent, index: int, frame: DapStackFrame) =
+#   # TODO
+#   discard
+
+# method onUpdatedStackTrace(self: CalltraceComponent, frames: seq[DapStackFrame]) =
+#   self.callLines = @[]
+#   self.args = JsAssoc[cstring, seq[CallKey]]()
+#   self.returnValues = JsAssoc[cstring, Value]()
+#   for i, frame in self.stackFrameToCallLine:
+#     self.processStackFrame(i, frame)
+#   self.redrawCallLines()
+#   self.redraw()
+
 func supportCallstackOnly(self: CalltraceComponent): bool =
-  not self.config.calltrace or self.locationLang() == LangRust
+  not self.config.calltrace or self.locationLang() == LangRust or not self.isDbBasedTrace
+
 
 method register*(self: CalltraceComponent, api: MediatorWithSubscribers) =
   self.api = api
@@ -868,7 +889,7 @@ proc registerCalltraceComponent*(component: CalltraceComponent, api: MediatorWit
   component.register(api)
 
 proc loadLines(self: CalltraceComponent, fromScroll: bool) =
-  if not (not self.isDbBasedTrace and fromScroll) or not self.loadedCallKeys.hasKey(self.lastSelectedCallKey):
+  if not self.isDbBasedTrace or not (not self.isDbBasedTrace and fromScroll) or not self.loadedCallKeys.hasKey(self.lastSelectedCallKey):
     let depth = self.panelDepth()
     let height = self.panelHeight()
     let startBuffer = self.getStartBufferLen()