use crate::analyzers::{Analyzer, Annotation, AnnotationKind, Limits};
use crate::binary::Binary;
#[derive(Debug, Clone)]
pub struct PanicsAnalyzer {
pub limits: Limits,
}
impl Default for PanicsAnalyzer {
fn default() -> Self {
Self::new()
}
}
impl PanicsAnalyzer {
#[must_use]
pub fn new() -> Self {
Self {
limits: Limits::default(),
}
}
#[must_use]
pub const fn with_limits(limits: Limits) -> Self {
Self { limits }
}
}
impl Analyzer for PanicsAnalyzer {
fn name(&self) -> &'static str {
"panics"
}
fn analyze(&self, bin: &Binary) -> Vec<Annotation> {
let mut out = Vec::new();
if bin.is_64 {
scan_locations::<8>(bin, &self.limits, &mut out);
} else {
scan_locations::<4>(bin, &self.limits, &mut out);
}
out
}
}
#[allow(
clippy::ptr_arg,
clippy::needless_pass_by_ref_mut,
clippy::cast_possible_truncation
)]
fn scan_locations<const WS: usize>(bin: &Binary, limits: &Limits, out: &mut Vec<Annotation>) {
let entry_size = WS * 2 + 4 + 4;
for sec in bin.sections() {
if !is_panic_container(&sec.name, sec.size) {
continue;
}
let data = sec.data.as_slice();
if data.len() < entry_size {
continue;
}
let mut off = 0usize;
while off + entry_size <= data.len() {
let Some(lookup) = sec.vaddr.checked_add(off as u64) else {
break;
};
let Some(file_ptr) = bin.read_ptr(lookup) else {
off += WS;
continue;
};
let Some(file_len_vaddr) = lookup.checked_add(WS as u64) else {
off += WS;
continue;
};
let Some(file_len) = bin.read_ptr(file_len_vaddr) else {
off += WS;
continue;
};
if !(1..=4096).contains(&file_len) {
off += WS;
continue;
}
if !bin.vaddr_in_string_section(file_ptr, file_len) {
off += WS;
continue;
}
let Some(line_off) = lookup.checked_add((WS as u64) * 2) else {
off += WS;
continue;
};
let Some(col_off) = line_off.checked_add(4) else {
off += WS;
continue;
};
let Some(line) = bin.read_u32(line_off) else {
off += WS;
continue;
};
let Some(col) = bin.read_u32(col_off) else {
off += WS;
continue;
};
if line == 0 || line > limits.max_line || col == 0 || col > limits.max_col {
off += WS;
continue;
}
let Some(bytes) = bin.read_at_vaddr(file_ptr, file_len as usize) else {
off += WS;
continue;
};
let Ok(file) = std::str::from_utf8(bytes) else {
off += WS;
continue;
};
#[allow(clippy::case_sensitive_file_extension_comparisons)]
if !file.ends_with(".rs") {
off += WS;
continue;
}
out.push(Annotation {
vaddr: lookup,
kind: AnnotationKind::PanicSite,
label: format!("{file}:{line}:{col}"),
comment: None,
});
off += entry_size + file_len as usize;
}
}
}
fn is_panic_container(name: &str, size: u64) -> bool {
if size < 16 {
return false;
}
matches!(name, ".rodata" | ".rdata")
|| name.starts_with(".rodata.")
|| name.starts_with(".rdata.")
|| name.starts_with(".data.rel.ro.")
}
#[cfg(test)]
mod tests {
use super::*;
use crate::binary::{Binary, BinaryFormat as Bf, Section};
#[test]
fn constants_distinct() {
let lim = Limits::default();
assert!(lim.max_line >= 100_000);
assert!(lim.max_col >= 100);
}
#[test]
fn analyzer_name_returns_panics() {
assert_eq!(PanicsAnalyzer::new().name(), "panics");
}
#[test]
fn is_panic_container_rejects_size_below_16() {
assert!(!is_panic_container(".rodata", 15));
}
#[test]
fn is_panic_container_accepts_size_exactly_16() {
assert!(is_panic_container(".rodata", 16));
}
#[test]
fn is_panic_container_rejects_non_rodata() {
assert!(!is_panic_container(".text", 256));
assert!(!is_panic_container(".data", 256));
assert!(!is_panic_container(".bss", 256));
}
#[test]
fn is_panic_container_accepts_all_rodata_variants() {
assert!(is_panic_container(".rodata", 64));
assert!(is_panic_container(".rdata", 64));
assert!(is_panic_container(".rodata.cst4", 64));
assert!(is_panic_container(".rdata.0", 64));
assert!(is_panic_container(".data.rel.ro.local", 64));
}
fn loc64(file_ptr: u64, file_len: u64, line: u32, col: u32) -> Vec<u8> {
let mut b = Vec::with_capacity(24);
b.extend_from_slice(&file_ptr.to_le_bytes());
b.extend_from_slice(&file_len.to_le_bytes());
b.extend_from_slice(&line.to_le_bytes());
b.extend_from_slice(&col.to_le_bytes());
b
}
fn panic_bin(rodata_data: Vec<u8>, string_vaddr: u64, string_data: Vec<u8>) -> Binary {
Binary::from_test_parts(
Bf::Elf,
true,
true,
vec![
Section {
name: ".rodata".into(),
vaddr: 0x1000,
size: rodata_data.len() as u64,
data: rodata_data,
},
Section {
name: ".rodata.str".into(),
vaddr: string_vaddr,
size: string_data.len() as u64,
data: string_data,
},
],
vec![],
vec![0, 1],
)
}
#[test]
fn scan_finds_single_panic_at_exact_entry_size() {
let sv = 0x4000u64;
let f = b"src/foo.rs";
let rd = loc64(sv, f.len() as u64, 42, 9);
assert_eq!(rd.len(), 24);
let bin = panic_bin(rd, sv, f.to_vec());
let anns = PanicsAnalyzer::new().analyze(&bin);
assert_eq!(anns.len(), 1);
assert_eq!(anns[0].label, "src/foo.rs:42:9");
}
#[test]
fn scan_finds_two_panics() {
let sv = 0x4000u64;
let f1 = b"src/foo.rs";
let f2 = b"src/bar.rs";
let mut rd = loc64(sv, f1.len() as u64, 42, 9);
rd.resize(34, 0);
rd.extend_from_slice(&loc64(sv + f1.len() as u64, f2.len() as u64, 7, 1));
let mut sd = Vec::new();
sd.extend_from_slice(f1);
sd.extend_from_slice(f2);
let bin = panic_bin(rd, sv, sd);
let anns = PanicsAnalyzer::new().analyze(&bin);
assert_eq!(anns.len(), 2);
}
#[test]
fn scan_skips_invalid_file_ptr_finds_valid() {
let sv = 0x4000u64;
let f = b"src/bar.rs";
let mut rd = loc64(0xDEAD_BEEF, 10, 42, 9);
rd.extend_from_slice(&loc64(sv, f.len() as u64, 7, 1));
let bin = panic_bin(rd, sv, f.to_vec());
let anns = PanicsAnalyzer::new().analyze(&bin);
assert!(anns.iter().any(|a| a.label == "src/bar.rs:7:1"));
}
#[test]
fn scan_skips_non_rs_filename_finds_valid() {
let sv = 0x4000u64;
let bad = b"src/foo.txt";
let good = b"src/bar.rs";
let mut rd = loc64(sv, bad.len() as u64, 42, 9);
rd.extend_from_slice(&loc64(sv + bad.len() as u64, good.len() as u64, 7, 1));
let mut sd = Vec::new();
sd.extend_from_slice(bad);
sd.extend_from_slice(good);
let bin = panic_bin(rd, sv, sd);
let anns = PanicsAnalyzer::new().analyze(&bin);
assert!(anns.iter().any(|a| a.label == "src/bar.rs:7:1"));
}
#[test]
fn scan_skips_invalid_utf8_finds_valid() {
let sv = 0x4000u64;
let bad: Vec<u8> = vec![0xFF, 0xFE, b'.', b'r', b's'];
let good = b"src/bar.rs";
let mut rd = loc64(sv, bad.len() as u64, 42, 9);
rd.extend_from_slice(&loc64(sv + bad.len() as u64, good.len() as u64, 7, 1));
let mut sd = Vec::new();
sd.extend_from_slice(&bad);
sd.extend_from_slice(good);
let bin = panic_bin(rd, sv, sd);
let anns = PanicsAnalyzer::new().analyze(&bin);
assert!(anns.iter().any(|a| a.label == "src/bar.rs:7:1"));
}
#[test]
fn scan_rejects_line_zero() {
let sv = 0x4000u64;
let f = b"src/foo.rs";
let rd = loc64(sv, f.len() as u64, 0, 9);
let bin = panic_bin(rd, sv, f.to_vec());
assert!(PanicsAnalyzer::new().analyze(&bin).is_empty());
}
#[test]
fn scan_rejects_col_zero() {
let sv = 0x4000u64;
let f = b"src/foo.rs";
let rd = loc64(sv, f.len() as u64, 42, 0);
let bin = panic_bin(rd, sv, f.to_vec());
assert!(PanicsAnalyzer::new().analyze(&bin).is_empty());
}
#[test]
fn scan_accepts_line_at_max_boundary() {
let lim = Limits {
max_line: 100,
max_col: 10_000,
..Limits::default()
};
let sv = 0x4000u64;
let f = b"src/foo.rs";
let rd = loc64(sv, f.len() as u64, 100, 9);
let bin = panic_bin(rd, sv, f.to_vec());
assert_eq!(PanicsAnalyzer::with_limits(lim).analyze(&bin).len(), 1);
}
#[test]
fn scan_rejects_line_above_max() {
let lim = Limits {
max_line: 100,
max_col: 10_000,
..Limits::default()
};
let sv = 0x4000u64;
let f = b"src/foo.rs";
let rd = loc64(sv, f.len() as u64, 101, 9);
let bin = panic_bin(rd, sv, f.to_vec());
assert!(PanicsAnalyzer::with_limits(lim).analyze(&bin).is_empty());
}
#[test]
fn scan_accepts_col_at_max_boundary() {
let lim = Limits {
max_line: 1_000_000,
max_col: 100,
..Limits::default()
};
let sv = 0x4000u64;
let f = b"src/foo.rs";
let rd = loc64(sv, f.len() as u64, 42, 100);
let bin = panic_bin(rd, sv, f.to_vec());
assert_eq!(PanicsAnalyzer::with_limits(lim).analyze(&bin).len(), 1);
}
#[test]
fn scan_rejects_col_above_max() {
let lim = Limits {
max_line: 1_000_000,
max_col: 100,
..Limits::default()
};
let sv = 0x4000u64;
let f = b"src/foo.rs";
let rd = loc64(sv, f.len() as u64, 42, 101);
let bin = panic_bin(rd, sv, f.to_vec());
assert!(PanicsAnalyzer::with_limits(lim).analyze(&bin).is_empty());
}
#[test]
fn scan_rejects_file_len_zero() {
let sv = 0x4000u64;
let rd = loc64(sv, 0, 42, 9);
let bin = panic_bin(rd, sv, b"src/foo.rs".to_vec());
assert!(PanicsAnalyzer::new().analyze(&bin).is_empty());
}
#[test]
fn scan_rejects_file_len_above_4096() {
let sv = 0x4000u64;
let rd = loc64(sv, 4097, 42, 9);
let bin = panic_bin(rd, sv, b"src/foo.rs".to_vec());
assert!(PanicsAnalyzer::new().analyze(&bin).is_empty());
}
#[test]
fn scan_rejects_section_smaller_than_entry_size() {
let sv = 0x4000u64;
let rd = vec![0u8; 23];
let bin = panic_bin(rd, sv, vec![]);
assert!(PanicsAnalyzer::new().analyze(&bin).is_empty());
}
#[test]
fn scan_accepts_section_exactly_entry_size() {
let sv = 0x4000u64;
let f = b"src/foo.rs";
let rd = loc64(sv, f.len() as u64, 42, 9);
assert_eq!(rd.len(), 24);
let bin = panic_bin(rd, sv, f.to_vec());
assert_eq!(PanicsAnalyzer::new().analyze(&bin).len(), 1);
}
#[test]
fn scan_finds_two_records_at_exact_entry_size_boundaries() {
let sv = 0x4000u64;
let f1 = b"src/a.rs"; let f2 = b"src/b.rs"; let mut rd = loc64(sv, f1.len() as u64, 1, 1); rd.resize(32, 0); rd.extend_from_slice(&loc64(sv + f1.len() as u64, f2.len() as u64, 2, 2));
let mut sd = Vec::new();
sd.extend_from_slice(f1);
sd.extend_from_slice(f2);
let bin = panic_bin(rd, sv, sd);
let anns = PanicsAnalyzer::new().analyze(&bin);
assert_eq!(
anns.len(),
2,
"two records must both be found; got {anns:?}"
);
}
fn manual_bin(
rodata_vaddr: u64,
rodata_size: u64,
rodata_data: Vec<u8>,
sec_by_vaddr: Vec<(u64, u64, usize)>,
string_sections: Vec<usize>,
string_data: Vec<u8>,
) -> Binary {
let sv = 0x4000u64;
Binary {
path: None,
format: Bf::Elf,
arch: "x86_64".into(),
is_64: true,
little_endian: true,
bytes: vec![],
sections: vec![
Section {
name: ".rodata".into(),
vaddr: rodata_vaddr,
size: rodata_size,
data: rodata_data,
},
Section {
name: ".rodata.str".into(),
vaddr: sv,
size: string_data.len() as u64,
data: string_data,
},
],
symbols: vec![],
sec_by_vaddr,
string_sections,
}
}
#[test]
fn scan_read_ptr_fails_does_not_panic() {
let bin = manual_bin(
0x1000,
48,
vec![0; 48],
vec![(0x4000, 0x400B, 1)], vec![1],
b"src/foo.rs".to_vec(),
);
assert!(PanicsAnalyzer::new().analyze(&bin).is_empty());
}
#[test]
fn scan_checked_add_file_len_vaddr_overflows_does_not_panic() {
let v = u64::MAX - 7;
let bin = manual_bin(
v,
24,
vec![0xFF; 24],
vec![(v, u64::MAX, 0), (0x4000, 0x400B, 1)],
vec![1],
b"src/foo.rs".to_vec(),
);
assert!(PanicsAnalyzer::new().analyze(&bin).is_empty());
}
#[test]
fn scan_read_ptr_file_len_fails_does_not_panic() {
let bin = manual_bin(
0x1000,
48,
vec![0; 48],
vec![(0x1000, 0x1008, 0), (0x4000, 0x400B, 1)], vec![1],
b"src/foo.rs".to_vec(),
);
assert!(PanicsAnalyzer::new().analyze(&bin).is_empty());
}
#[test]
fn scan_checked_add_line_off_overflows_does_not_panic() {
let v = u64::MAX - 15;
let mut data = vec![0u8; 24];
data[0..8].copy_from_slice(&0x4000u64.to_le_bytes());
data[8..16].copy_from_slice(&10u64.to_le_bytes());
let bin = manual_bin(
v,
24,
data,
vec![(v, u64::MAX, 0), (0x4000, 0x400B, 1)],
vec![1],
b"src/foo.rs".to_vec(),
);
assert!(PanicsAnalyzer::new().analyze(&bin).is_empty());
}
#[test]
fn scan_checked_add_col_off_overflows_does_not_panic() {
let v = u64::MAX - 19;
let mut data = vec![0u8; 24];
data[0..8].copy_from_slice(&0x4000u64.to_le_bytes()); data[8..16].copy_from_slice(&10u64.to_le_bytes()); data[16..20].copy_from_slice(&1u32.to_le_bytes()); let bin = manual_bin(
v,
24,
data,
vec![(v, u64::MAX, 0), (0x4000, 0x400B, 1)],
vec![1],
b"src/foo.rs".to_vec(),
);
assert!(PanicsAnalyzer::new().analyze(&bin).is_empty());
}
#[test]
fn scan_read_u32_line_fails_does_not_panic() {
let mut data = vec![0u8; 24];
data[0..8].copy_from_slice(&0x4000u64.to_le_bytes()); data[8..16].copy_from_slice(&10u64.to_le_bytes()); let bin = manual_bin(
0x1000,
24,
data,
vec![(0x1000, 0x1010, 0), (0x4000, 0x400B, 1)], vec![1],
b"src/foo.rs".to_vec(),
);
assert!(PanicsAnalyzer::new().analyze(&bin).is_empty());
}
#[test]
fn scan_read_u32_col_fails_does_not_panic() {
let mut data = vec![0u8; 24];
data[0..8].copy_from_slice(&0x4000u64.to_le_bytes()); data[8..16].copy_from_slice(&10u64.to_le_bytes()); data[16..20].copy_from_slice(&1u32.to_le_bytes()); let bin = manual_bin(
0x1000,
24,
data,
vec![(0x1000, 0x1014, 0), (0x4000, 0x400B, 1)], vec![1],
b"src/foo.rs".to_vec(),
);
assert!(PanicsAnalyzer::new().analyze(&bin).is_empty());
}
#[test]
fn scan_read_at_vaddr_extends_beyond_does_not_panic() {
let sv = 0x4000u64;
let rd = loc64(sv, 10, 42, 9); let bin = panic_bin(rd, sv, b"abcde".to_vec()); assert!(PanicsAnalyzer::new().analyze(&bin).is_empty());
}
#[test]
fn scan_read_at_vaddr_fails_then_finds_valid() {
let sv = 0x4000u64;
let mut rd = loc64(sv, 100, 42, 9); rd.extend_from_slice(&loc64(sv, 10, 7, 1)); let sd = b"src/bar.rs\0".to_vec(); let bin = panic_bin(rd, sv, sd);
let anns = PanicsAnalyzer::new().analyze(&bin);
assert!(
anns.iter().any(|a| a.label == "src/bar.rs:7:1"),
"valid record after read_at_vaddr failure must be found"
);
}
}