feat(debugger): better at function breakpoints:

= now by line breakpoints can be set on one or more places in program
- now by line breakpoints may set by part of file name or full file path

Author: godzie44

src/debugger/command/break.rs

@@ -37,9 +37,7 @@ impl<'a> Break<'a> {
                     Breakpoint::Address(addr) => {
                         vec![self.dbg.set_breakpoint_at_addr(addr.into())?]
                     }
-                    Breakpoint::Line(file, line) => {
-                        vec![self.dbg.set_breakpoint_at_line(&file, line)?]
-                    }
+                    Breakpoint::Line(file, line) => self.dbg.set_breakpoint_at_line(&file, line)?,
                     Breakpoint::Function(func_name) => self.dbg.set_breakpoint_at_fn(&func_name)?,
                 };
                 HandlingResult::New(res)
@@ -51,11 +49,9 @@ impl<'a> Break<'a> {
                         .remove_breakpoint_at_addr(addr.into())?
                         .map(|brkpt| vec![brkpt])
                         .unwrap_or_default(),
-                    Breakpoint::Line(file, line) => self
-                        .dbg
-                        .remove_breakpoint_at_line(&file, line)?
-                        .map(|brkpt| vec![brkpt])
-                        .unwrap_or_default(),
+                    Breakpoint::Line(file, line) => {
+                        self.dbg.remove_breakpoint_at_line(&file, line)?
+                    }
                     Breakpoint::Function(func_name) => {
                         self.dbg.remove_breakpoint_at_fn(&func_name)?
                     }

src/debugger/debugee/dwarf/mod.rs

@@ -19,6 +19,7 @@ use crate::debugger::debugee::dwarf::unit::{
     DieRef, DieVariant, DwarfUnitParser, Entry, FunctionDie, Node, ParameterDie,
     PlaceDescriptorOwned, Unit, VariableDie,
 };
+use crate::debugger::debugee::dwarf::utils::PathSearchIndex;
 use crate::debugger::debugee::{Debugee, Location};
 use crate::debugger::register::{DwarfRegisterMap, RegisterMap};
 use crate::debugger::ExplorationContext;
@@ -38,9 +39,9 @@ use object::{Object, ObjectSection};
 use rayon::prelude::*;
 use regex::Regex;
 use std::collections::{HashSet, VecDeque};
-use std::fs;
 use std::ops::{Add, Deref};
 use std::path::{Path, PathBuf};
+use std::{fs, path};
 pub use symbol::Symbol;
 use unit::PlaceDescriptor;
 use walkdir::WalkDir;
@@ -55,6 +56,9 @@ pub struct DebugInformation<R: gimli::Reader = EndianArcSlice> {
     units: Option<Vec<Unit>>,
     symbol_table: Option<SymbolTab>,
     pub_names: Option<HashSet<String>>,
+    /// Index for fast search files by full path or part of file path. Contains unit index and
+    /// indexes of lines in [`Unit::lines`] vector that belongs to a file, indexes ordered by line number.
+    files_index: PathSearchIndex<(usize, Vec<usize>)>,
 }
 
 impl Clone for DebugInformation {
@@ -82,6 +86,7 @@ impl Clone for DebugInformation {
             units: self.units.clone(),
             symbol_table: self.symbol_table.clone(),
             pub_names: self.pub_names.clone(),
+            files_index: self.files_index.clone(),
         }
     }
 }
@@ -325,11 +330,40 @@ impl DebugInformation {
             .collect())
     }
 
-    pub fn find_place(&self, file: &str, line: u64) -> Result<Option<PlaceDescriptor<'_>>> {
-        Ok(self
-            .get_units()?
-            .iter()
-            .find_map(|unit| unit.find_stmt_line(file, line)))
+    /// Return closest [`PlaceDescriptor`] for given file and line.
+    /// Closest means that returns descriptor for target line or, if no descriptor for target line,
+    /// place for next line after target.
+    ///
+    /// # Arguments
+    ///
+    /// * `file`: file name template (full path or part of a file path)
+    /// * `line`: line number
+    pub fn find_closest_place(
+        &self,
+        file_tpl: &str,
+        line: u64,
+    ) -> Result<Vec<PlaceDescriptor<'_>>> {
+        let files = self.files_index.get(file_tpl);
+
+        let mut result = vec![];
+        for (unit_idx, file_lines) in files {
+            let unit = self.unit_ensure(*unit_idx);
+            for line_idx in file_lines {
+                let line_row = unit.line(*line_idx);
+                if line_row.line < line {
+                    continue;
+                }
+                if line_row.line > line + 1 {
+                    break;
+                }
+
+                if let Some(place) = unit.find_place_by_idx(*line_idx) {
+                    result.push(place);
+                    break;
+                }
+            }
+        }
+        Ok(result)
     }
 
     /// Search all places for functions that relevant to template.
@@ -608,6 +642,7 @@ impl DebugInformationBuilder {
                 units: None,
                 symbol_table,
                 pub_names,
+                files_index: PathSearchIndex::new(""),
             });
         }
 
@@ -622,6 +657,14 @@ impl DebugInformationBuilder {
         units.sort_unstable_by_key(|u| u.offset());
         units.iter_mut().enumerate().for_each(|(i, u)| u.set_idx(i));
 
+        let mut files_index = PathSearchIndex::new(path::MAIN_SEPARATOR_STR);
+        units.iter().for_each(|unit| {
+            unit.file_path_with_lines_pairs()
+                .for_each(|(file_path, lines)| {
+                    files_index.insert(file_path, (unit.idx(), lines));
+                });
+        });
+
         Ok(DebugInformation {
             file: obj_path.to_path_buf(),
             inner: dwarf,
@@ -630,6 +673,7 @@ impl DebugInformationBuilder {
             units: Some(units),
             symbol_table,
             pub_names,
+            files_index,
         })
     }
 }

src/debugger/debugee/dwarf/unit/mod.rs

@@ -15,19 +15,20 @@ use once_cell::sync::OnceCell;
 use std::cell::RefCell;
 use std::collections::HashMap;
 use std::fmt::{Debug, Formatter};
+use std::path;
 use std::path::{Path, PathBuf};
 use uuid::Uuid;
 
 /// A row in the line number program's resulting matrix.
 #[derive(PartialEq, Debug, Clone)]
-struct LineRow {
-    address: u64,
-    file_index: u64,
-    line: u64,
-    column: u64,
-    is_stmt: bool,
-    prolog_end: bool,
-    epilog_begin: bool,
+pub(super) struct LineRow {
+    pub(super) address: u64,
+    pub(super) file_index: u64,
+    pub(super) line: u64,
+    pub(super) column: u64,
+    pub(super) is_stmt: bool,
+    pub(super) prolog_end: bool,
+    pub(super) epilog_begin: bool,
 }
 
 /// An address range of debug information entry,
@@ -76,7 +77,7 @@ impl<'a> Debug for PlaceDescriptor<'a> {
 
 impl<'a> PlaceDescriptor<'a> {
     pub fn next(&self) -> Option<PlaceDescriptor<'a>> {
-        self.unit.find_place(self.pos_in_unit + 1)
+        self.unit.find_place_by_idx(self.pos_in_unit + 1)
     }
 
     pub fn line_eq(&self, other: &PlaceDescriptor) -> bool {
@@ -489,13 +490,13 @@ impl Unit {
     }
 
     /// Return [`PlaceDescriptor`] by index for lines vector in unit.
-    fn find_place(&self, line_pos: usize) -> Option<PlaceDescriptor> {
+    pub(super) fn find_place_by_idx(&self, line_pos: usize) -> Option<PlaceDescriptor> {
         let line = self.lines.get(line_pos)?;
         Some(PlaceDescriptor {
             file: self
                 .files
                 .get(line.file_index as usize)
-                .expect("parse error"),
+                .expect("unreachable: file must exists"),
             address: line.address.into(),
             line_number: line.line,
             column_number: line.column,
@@ -507,6 +508,10 @@ impl Unit {
         })
     }
 
+    pub(super) fn line(&self, index: usize) -> &LineRow {
+        &self.lines[index]
+    }
+
     /// Return nearest [`PlaceDescriptor`] for given program counter.
     ///
     /// # Arguments
@@ -519,7 +524,7 @@ impl Unit {
             Err(p) => p - 1,
         };
 
-        self.find_place(pos)
+        self.find_place_by_idx(pos)
     }
 
     /// Return place with address equals to given program counter.
@@ -530,32 +535,11 @@ impl Unit {
     pub fn find_exact_place_by_pc(&self, pc: GlobalAddress) -> Option<PlaceDescriptor> {
         let pc = u64::from(pc);
         match self.lines.binary_search_by_key(&pc, |line| line.address) {
-            Ok(p) => self.find_place(p),
+            Ok(p) => self.find_place_by_idx(p),
             Err(_) => None,
         }
     }
 
-    /// Return [`PlaceDescriptor`] for given file and line.
-    ///
-    /// # Arguments
-    ///
-    /// * `file`: file name
-    /// * `line`: line number
-    pub fn find_stmt_line(&self, file: &str, line: u64) -> Option<PlaceDescriptor<'_>> {
-        let found = self
-            .files
-            .iter()
-            .enumerate()
-            .find(|(_, file_path)| file_path.ends_with(file))?;
-        for (pos, line_row) in self.lines.iter().enumerate() {
-            if line_row.line == line && line_row.file_index == found.0 as u64 {
-                return self.find_place(pos);
-            }
-        }
-
-        None
-    }
-
     /// Return list on debug entries.
     /// Note: this method requires a full unit.
     pub fn entries(&self) -> UnitResult<&Vec<Entry>> {
@@ -663,4 +647,38 @@ impl Unit {
     pub fn files(&self) -> &[PathBuf] {
         &self.files
     }
+
+    /// Return pairs (file path, indexes of file lines in unit.lines list). This useful for
+    /// create searching indexes.
+    pub(super) fn file_path_with_lines_pairs(
+        &self,
+    ) -> impl Iterator<Item = (impl IntoIterator<Item = impl ToString + '_>, Vec<usize>)> {
+        let mut grouped_by_file_lines = HashMap::new();
+        for (line_idx, line) in self.lines.iter().enumerate() {
+            let file_idx = line.file_index as usize;
+            let entry = grouped_by_file_lines.entry(file_idx).or_insert(vec![]);
+            entry.push(line_idx)
+        }
+
+        self.files
+            .iter()
+            .enumerate()
+            .filter_map(move |(idx, file)| {
+                let mut file_lines = grouped_by_file_lines.get(&idx).cloned().unwrap_or_default();
+                // files without lines not interests
+                if file_lines.is_empty() {
+                    return None;
+                }
+
+                file_lines.sort_unstable_by_key(|line| self.lines[*line].line);
+
+                Some((
+                    file.iter().filter_map(|s| {
+                        let s = s.to_string_lossy();
+                        (s != path::MAIN_SEPARATOR_STR).then_some(s)
+                    }),
+                    file_lines,
+                ))
+            })
+    }
 }

src/debugger/debugee/dwarf/unit/parser.rs

@@ -151,7 +151,7 @@ impl<'a> DwarfUnitParser<'a> {
                     if let Some(ref fn_name) = base_attrs.name {
                         // function without range are useless for this index
                         if !base_attrs.ranges.is_empty() {
-                            function_index.insert_w_head(&fn_ns, fn_name, current_idx);
+                            function_index.insert_w_head(fn_ns.iter(), fn_name, current_idx);
                         }
                     }
 
@@ -373,7 +373,7 @@ where
     let header = rows.header();
     match header.file(0) {
         Some(file) => files.push(render_file_path(unit, file, header, dwarf)?),
-        None => files.push(PathBuf::from("")),
+        None => files.push(PathBuf::default()),
     }
     let mut index = 1;
     while let Some(file) = header.file(index) {