feat: try to generalize a bit of move to first flow step logic: prepare jump_to_call

TODO: rr jump_to_call

Author: alehander92

src/db-backend/src/bin/virtualization-layers.rs

@@ -20,8 +20,9 @@ use std::path::PathBuf;
 extern crate db_backend;
 use db_backend::core::Core;
 use db_backend::db::Db;
-use db_backend::handler::{Handler, TraceKind};
+use db_backend::handler::Handler;
 use db_backend::rr_dispatcher::CtRRArgs;
+use db_backend::task::TraceKind;
 // use db_backend::receiver::Receiver;
 // use db_backend::response::Response;
 

src/db-backend/src/dap_server.rs

@@ -2,13 +2,13 @@ use crate::dap::{self, Capabilities, DapMessage, Event, ProtocolMessage, Respons
 use crate::dap_types;
 
 use crate::db::Db;
-use crate::handler::{Handler, TraceKind};
+use crate::handler::Handler;
 use crate::paths::CODETRACER_PATHS;
 use crate::rr_dispatcher::CtRRArgs;
 use crate::task::{
     Action, CallSearchArg, CalltraceLoadArgs, CollapseCallsArgs, CtLoadFlowArguments,
     CtLoadLocalsArguments, FunctionLocation, LoadHistoryArg, LocalStepJump, Location, ProgramEvent, RunTracepointsArg,
-    SourceCallJumpTarget, SourceLocation, StepArg, TracepointId, UpdateTableArgs,
+    SourceCallJumpTarget, SourceLocation, StepArg, TraceKind, TracepointId, UpdateTableArgs,
 };
 
 use crate::trace_processor::{load_trace_data, load_trace_metadata, TraceProcessor};

src/db-backend/src/db.rs

@@ -15,7 +15,7 @@ use crate::distinct_vec::DistinctVec;
 use crate::expr_loader::ExprLoader;
 use crate::lang::Lang;
 use crate::replay::{Events, Replay};
-use crate::task::{Action, Breakpoint, Call, CallArg, Location, ProgramEvent, RRTicks, NO_INDEX, NO_PATH, NO_POSITION, CtLoadLocalsArguments, Variable};
+use crate::task::{Action, Breakpoint, Call, CallArg, CoreTrace, Location, ProgramEvent, RRTicks, NO_INDEX, NO_PATH, NO_POSITION, CtLoadLocalsArguments, Variable};
 use crate::value::{Type, Value};
 
 const NEXT_INTERNAL_STEP_OVERS_LIMIT: usize = 1_000;
@@ -1050,7 +1050,7 @@ impl Replay for DbReplay {
         // let path_id = path_id_res?;
         // let inner_map = &mut self.breakpoint_list[path_id.0];
         // inner_map.remove(&loc.line);
-        todo!()        
+        todo!()       
     }
 
     fn delete_breakpoints(&mut self) -> Result<bool, Box<dyn Error>> {
@@ -1070,6 +1070,15 @@ impl Replay for DbReplay {
         Ok(toggled_breakpoint)
     }
 
+    fn jump_to_call(&mut self, location: &Location) -> Result<Location, Box<dyn Error>> {
+        let step = self.db.steps[StepId(location.rr_ticks.0)];
+        let call_key = step.call_key;
+        let first_call_step_id = self.db.calls[call_key].step_id;
+        self.jump_to(first_call_step_id)?;
+        let mut expr_loader = ExprLoader::new(CoreTrace::default());
+        self.load_location(&mut expr_loader)
+    }
+
     fn current_step_id(&mut self) -> StepId {
         self.step_id
     }

src/db-backend/src/diff.rs

@@ -9,6 +9,7 @@ use runtime_tracing::FunctionId;
 use log::info;
 
 use crate::db::{Db,DbReplay};
+use crate::task::TraceKind;
 use crate::trace_processor::{load_trace_data, load_trace_metadata, TraceProcessor};
 use crate::flow_preloader::FlowPreloader;
 
@@ -147,7 +148,7 @@ pub fn index_diff(diff: Diff, trace_folder: &Path, multitrace_folder: &Path) ->
     info!("diff_lines {diff_lines:?}");
     let mut flow_preloader = FlowPreloader::new();
     let mut replay = DbReplay::new(Box::new(db.clone()));
-    let flow_update = flow_preloader.load_diff_flow(diff_lines, &db, &mut replay);
+    let flow_update = flow_preloader.load_diff_flow(diff_lines, &db, TraceKind::DB, &mut replay);
 
     let raw = serde_json::to_string(&flow_update)?;
     std::fs::write(multitrace_folder.join("diff_index.json"), raw)?;

src/db-backend/src/flow_preloader.rs

@@ -3,7 +3,7 @@ use crate::{
     expr_loader::ExprLoader,
     task::{
         Action, BranchesTaken, CoreTrace, FlowEvent, FlowStep, FlowUpdate, FlowUpdateState, FlowUpdateStateKind,
-        FlowMode, FlowViewUpdate, Iteration, Location, Loop, LoopId, LoopIterationSteps, Position, RRTicks, StepCount
+        FlowMode, FlowViewUpdate, Iteration, Location, Loop, LoopId, LoopIterationSteps, Position, RRTicks, StepCount, TraceKind,
     },
     replay::Replay,
     value::Value,
@@ -27,13 +27,13 @@ impl FlowPreloader {
         }
     }
 
-    pub fn load(&mut self, location: Location, mode: FlowMode, replay: &mut dyn Replay) -> FlowUpdate {
+    pub fn load(&mut self, location: Location, mode: FlowMode, kind: TraceKind, replay: &mut dyn Replay) -> FlowUpdate {
         info!("flow: load: {:?}", location);
         let path_buf = PathBuf::from(&location.path);
         match self.expr_loader.load_file(&path_buf) {
             Ok(_) => {
                 info!("Expression loader complete!");
-                let mut call_flow_preloader: CallFlowPreloader = CallFlowPreloader::new(self, location.clone(), HashSet::new(), HashSet::new(), mode);
+                let mut call_flow_preloader: CallFlowPreloader = CallFlowPreloader::new(self, location.clone(), HashSet::new(), HashSet::new(), mode, kind);
                 call_flow_preloader.load_flow(location, replay)
             }
             Err(e) => {
@@ -43,7 +43,7 @@ impl FlowPreloader {
         }
     }
 
-    pub fn load_diff_flow(&mut self, diff_lines: HashSet<(PathBuf, i64)>, db: &Db, replay: &mut dyn Replay) -> FlowUpdate {
+    pub fn load_diff_flow(&mut self, diff_lines: HashSet<(PathBuf, i64)>, db: &Db, trace_kind: TraceKind, replay: &mut dyn Replay) -> FlowUpdate {
         info!("load_diff_flow");
         for diff_line in &diff_lines {
             match self.expr_loader.load_file(&diff_line.0) {
@@ -69,7 +69,7 @@ impl FlowPreloader {
             }
         }
 
-        let mut call_flow_preloader = CallFlowPreloader::new(self, Location::default(), diff_lines, diff_call_keys, FlowMode::Diff);
+        let mut call_flow_preloader = CallFlowPreloader::new(self, Location::default(), diff_lines, diff_call_keys, FlowMode::Diff, trace_kind);
         let location = Location { line: 1, ..Location::default() };
         call_flow_preloader.load_flow(location, replay)
     }
@@ -97,10 +97,17 @@ pub struct CallFlowPreloader<'a> {
     diff_lines: HashSet<(PathBuf, i64)>,
     diff_call_keys: HashSet<i64>, //  TODO: if we add Eq, Hash it seems we can do CallKey
     mode: FlowMode,
+    trace_kind: TraceKind,
 }
 
 impl<'a> CallFlowPreloader<'a> {
-    pub fn new(flow_preloader: &'a FlowPreloader, location: Location, diff_lines: HashSet<(PathBuf, i64)>, diff_call_keys: HashSet<i64>, mode: FlowMode) -> Self {
+    pub fn new(
+            flow_preloader: &'a FlowPreloader,
+            location: Location,
+            diff_lines: HashSet<(PathBuf, i64)>,
+            diff_call_keys: HashSet<i64>,
+            mode: FlowMode,
+            trace_kind: TraceKind) -> Self {
         CallFlowPreloader {
             flow_preloader,
             location,
@@ -110,6 +117,7 @@ impl<'a> CallFlowPreloader<'a> {
             diff_lines,
             diff_call_keys,
             mode,
+            trace_kind,
         }
     }
 
@@ -236,11 +244,17 @@ impl<'a> CallFlowPreloader<'a> {
     }
 
     fn move_to_first_step(&self, from_step_id: StepId, replay: &mut dyn Replay) -> Result<(StepId, bool), Box<dyn Error>> {
-        let (step_id, progressing) = match self.mode {
+        let (mut step_id, mut progressing) = match self.mode {
             FlowMode::Call => (from_step_id, true),
             FlowMode::Diff => self.next_diff_flow_step(StepId(0), true, replay),
         };
-        replay.jump_to(step_id)?;
+        if self.trace_kind == TraceKind::DB {
+            replay.jump_to(step_id)?;
+        } else {
+            let location = replay.jump_to_call(&self.location)?;
+            step_id = StepId(location.rr_ticks.0);
+            progressing = true;
+        }
         Ok((step_id, progressing))
     }
 

src/db-backend/src/handler.rs

@@ -27,7 +27,7 @@ use crate::task::{
     CollapseCallsArgs, CoreTrace, DbEventKind, FrameInfo, FunctionLocation, FlowMode, HistoryResult, HistoryUpdate, Instruction,
     CtLoadFlowArguments, FlowUpdate, Instructions, LoadHistoryArg, LoadStepLinesArg, LoadStepLinesUpdate, LocalStepJump, Location, MoveState,
     Notification, NotificationKind, ProgramEvent, RRGDBStopSignal, RRTicks, RegisterEventsArg, RunTracepointsArg,
-    SourceCallJumpTarget, SourceLocation, StepArg, Stop, StopType, Task, TraceUpdate, TracepointId, TracepointResults,
+    SourceCallJumpTarget, SourceLocation, StepArg, Stop, StopType, Task, TraceKind, TraceUpdate, TracepointId, TracepointResults,
     UpdateTableArgs, Variable, NO_INDEX, NO_PATH, NO_POSITION, NO_STEP_ID,
 };
 use crate::tracepoint_interpreter::TracepointInterpreter;
@@ -60,12 +60,6 @@ pub struct Handler {
     pub load_flow_index: usize,
 }
 
-#[derive(Debug, Clone, PartialEq)]
-pub enum TraceKind {
-    DB,
-    RR,
-}
-
 // two choices:
 //   return results and potentially
 //   generate multiple events as a generator
@@ -454,7 +448,7 @@ impl Handler {
         // if possible for example
 
         let flow_update = if arg.flow_mode == FlowMode::Call {
-            self.flow_preloader.load(arg.location, arg.flow_mode, &mut *flow_replay)
+            self.flow_preloader.load(arg.location, arg.flow_mode, self.trace_kind, &mut *flow_replay)
         } else {
             if let Some(raw_flow) = &self.raw_diff_index {
                 serde_json::from_str::<FlowUpdate>(&raw_flow)?

src/db-backend/src/query.rs

@@ -1,6 +1,6 @@
 use serde::{Deserialize, Serialize};
 
-use crate::task::{Action, Breakpoint, CtLoadLocalsArguments};
+use crate::task::{Action, Breakpoint, CtLoadLocalsArguments, Location};
 
 #[derive(Debug, Clone, Serialize, Deserialize)]
 #[serde(tag = "kind")]
@@ -15,4 +15,5 @@ pub enum CtRRQuery {
     DeleteBreakpoint { breakpoint: Breakpoint, },
     DeleteBreakpoints,
     ToggleBreakpoint { breakpoint: Breakpoint, },
+    JumpToCall { location: Location },
 }

src/db-backend/src/replay.rs

@@ -27,5 +27,6 @@ pub trait Replay: std::fmt::Debug {
     fn delete_breakpoint(&mut self, breakpoint: &Breakpoint) -> Result<bool, Box<dyn Error>>;
     fn delete_breakpoints(&mut self) -> Result<bool, Box<dyn Error>>;
     fn toggle_breakpoint(&mut self, breakpoint: &Breakpoint) -> Result<Breakpoint, Box<dyn Error>>;
+    fn jump_to_call(&mut self, location: &Location) -> Result<Location, Box<dyn Error>>;
     fn current_step_id(&mut self) -> StepId;
 }

src/db-backend/src/rr_dispatcher.rs

@@ -265,6 +265,15 @@ impl Replay for RRDispatcher {
         )?)
     }
 
+    fn jump_to_call(&mut self, location: &Location) -> Result<Location, Box<dyn Error>> {
+        self.ensure_active_stable()?;
+        Ok(serde_json::from_str::<Location>(
+            &self.stable.run_query(
+                CtRRQuery::JumpToCall { location: location.clone() }
+            )?
+        )?)
+    }
+
     fn current_step_id(&mut self) -> StepId {
         // cache location or step_id and return
         // OR always load from worker

src/db-backend/src/step_lines_loader.rs

@@ -9,7 +9,7 @@ use crate::db::{Db, DbStep, DbReplay};
 use crate::distinct_vec::DistinctVec;
 use crate::expr_loader::ExprLoader;
 use crate::flow_preloader::FlowPreloader;
-use crate::task::{FlowMode, LineStep, LineStepKind, LineStepValue, Location};
+use crate::task::{FlowMode, LineStep, LineStepKind, LineStepValue, Location, TraceKind};
 
 #[derive(Debug, Clone)]
 pub struct StepLinesLoader {
@@ -87,7 +87,7 @@ impl StepLinesLoader {
                 // let function_id = db.calls[call_key].function_id;
                 // let function_first = db.functions[function_id].line;
                 let mut replay = DbReplay::new(Box::new(db.clone()));
-                let flow_update = flow_preloader.load(location, FlowMode::Call, &mut replay);
+                let flow_update = flow_preloader.load(location, FlowMode::Call, TraceKind::DB, &mut replay);
                 if !flow_update.error && !flow_update.view_updates.is_empty() {
                     let flow_view_update = &flow_update.view_updates[0];
                     for flow_step in flow_view_update.steps.iter() {