use crate::analyzers::{Analyzer, Annotation, AnnotationKind, Limits, RecoveredAnnotationBudget};
use crate::binary::Binary;
const MIN_PANIC_FILENAME_BYTES: usize = ".rs".len();
const MIN_PANIC_LABEL_SUFFIX_BYTES: usize = 2 + 1 + 1;
const MIN_PANIC_LABEL_BYTES: usize = MIN_PANIC_FILENAME_BYTES + MIN_PANIC_LABEL_SUFFIX_BYTES;
#[cfg(test)]
thread_local! {
static CANDIDATE_CONTENT_READS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) };
}
#[cfg(test)]
fn reset_candidate_content_reads() {
CANDIDATE_CONTENT_READS.with(|reads| reads.set(0));
}
#[cfg(test)]
fn candidate_content_reads() -> usize {
CANDIDATE_CONTENT_READS.with(std::cell::Cell::get)
}
#[cfg(test)]
fn record_candidate_content_read() {
CANDIDATE_CONTENT_READS.with(|reads| reads.set(reads.get().saturating_add(1)));
}
#[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::too_many_lines)]
fn scan_locations<const WS: usize>(bin: &Binary, limits: &Limits, out: &mut Vec<Annotation>) {
let entry_size = WS * 2 + 4 + 4;
let mut budget = RecoveredAnnotationBudget::for_string_sections(bin, WS);
for (section_index, sec) in bin.sections().iter().enumerate() {
if !bin.is_string_section_index(section_index) {
continue;
}
let data = sec.data.as_slice();
if data.len() < entry_size {
continue;
}
let mut off = 0usize;
while off + entry_size <= data.len() {
if budget.cannot_fit_any_annotation(MIN_PANIC_LABEL_BYTES) {
return;
}
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;
};
let Ok(file_len_usize) = usize::try_from(file_len) else {
off += WS;
continue;
};
if file_len_usize < MIN_PANIC_FILENAME_BYTES || file_len_usize > limits.max_string_len {
off += WS;
continue;
}
if !budget
.can_fit_annotation_with_minimum_text(minimum_panic_label_bytes(file_len_usize))
{
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;
}
#[cfg(test)]
record_candidate_content_read();
let Some(bytes) = bin.read_at_vaddr(file_ptr, file_len_usize) else {
off += WS;
continue;
};
let bytes = bytes.strip_suffix(&[0]).unwrap_or(bytes);
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;
}
let label_len = file
.len()
.saturating_add(2)
.saturating_add(decimal_digits(line))
.saturating_add(decimal_digits(col));
if !budget.try_consume(label_len) {
off += WS;
continue;
}
out.push(Annotation {
vaddr: lookup,
kind: AnnotationKind::PanicSite,
label: format!("{file}:{line}:{col}"),
comment: None,
});
off += WS;
}
}
}
const fn minimum_panic_label_bytes(file_len: usize) -> usize {
let filename_bytes = if file_len > MIN_PANIC_FILENAME_BYTES {
file_len - 1
} else {
file_len
};
filename_bytes.saturating_add(MIN_PANIC_LABEL_SUFFIX_BYTES)
}
const fn decimal_digits(value: u32) -> usize {
if value >= 1_000_000_000 {
10
} else if value >= 100_000_000 {
9
} else if value >= 10_000_000 {
8
} else if value >= 1_000_000 {
7
} else if value >= 100_000 {
6
} else if value >= 10_000 {
5
} else if value >= 1_000 {
4
} else if value >= 100 {
3
} else if value >= 10 {
2
} else {
1
}
}
#[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 decimal_digits_covers_u32_boundaries() {
assert_eq!(decimal_digits(0), 1);
assert_eq!(decimal_digits(9), 1);
assert_eq!(decimal_digits(10), 2);
assert_eq!(decimal_digits(999_999_999), 9);
assert_eq!(decimal_digits(u32::MAX), 10);
}
#[test]
fn minimum_panic_label_bytes_allows_one_trailing_nul() {
assert_eq!(minimum_panic_label_bytes(3), 7);
assert_eq!(minimum_panic_label_bytes(4), 7);
assert_eq!(minimum_panic_label_bytes(5), 8);
}
#[test]
fn analyzer_name_returns_panics() {
assert_eq!(PanicsAnalyzer::new().name(), "panics");
}
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.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_preserves_distinct_line_and_column_records_for_one_file() {
let sv = 0x4000u64;
let file = b"src/foo.rs";
let mut records = loc64(sv, file.len() as u64, 42, 9);
records.extend_from_slice(&loc64(sv, file.len() as u64, 43, 1));
let anns = PanicsAnalyzer::new().analyze(&panic_bin(records, sv, file.to_vec()));
assert_eq!(anns.len(), 2);
assert!(anns.iter().any(|ann| ann.label == "src/foo.rs:42:9"));
assert!(anns.iter().any(|ann| ann.label == "src/foo.rs:43:1"));
}
#[test]
fn scan_caps_aggregate_owned_labels_against_backing_bytes() {
let sv = 0x4000u64;
let mut file = vec![b'a'; 4088];
file.extend_from_slice(b".rs");
let mut records = Vec::new();
for offset in 0..3u64 {
records.extend_from_slice(&loc64(
sv + offset,
(file.len() as u64).saturating_sub(offset),
42,
9,
));
}
let backing_bytes = records.len() + file.len();
let anns = PanicsAnalyzer::new().analyze(&panic_bin(records, sv, file));
let emitted_text = anns.iter().fold(0usize, |total, annotation| {
total.saturating_add(annotation.label.len())
});
assert_eq!(anns.len(), 2);
assert!(emitted_text <= backing_bytes.saturating_mul(2));
}
#[test]
fn scan_skips_over_budget_panic_files_before_content_read() {
let sv = 0x4000u64;
let mut file = vec![b'a'; 4088];
file.extend_from_slice(b".rs");
let mut records = Vec::new();
for offset in 0..4u64 {
records.extend_from_slice(&loc64(
sv + offset,
(file.len() as u64).saturating_sub(offset),
42,
9,
));
}
let bin = panic_bin(records, sv, file);
reset_candidate_content_reads();
let anns = PanicsAnalyzer::new().analyze(&bin);
assert_eq!(anns.len(), 2);
assert_eq!(candidate_content_reads(), 2);
assert!(anns
.iter()
.all(|annotation| annotation.label.ends_with(":42:9")));
}
#[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_respects_custom_max_string_len() {
let sv = 0x4000u64;
let f = b"src/foo.rs";
let rd = loc64(sv, f.len() as u64, 42, 9);
let bin = panic_bin(rd, sv, f.to_vec());
let limits = Limits {
max_string_len: f.len() - 1,
..Limits::default()
};
assert!(PanicsAnalyzer::with_limits(limits).analyze(&bin).is_empty());
}
#[test]
fn scan_accepts_one_trailing_filename_nul() {
let sv = 0x4000u64;
let f = b"src/foo.rs\0";
let rd = loc64(sv, f.len() as u64, 42, 9);
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_rejects_two_trailing_filename_nuls() {
let sv = 0x4000u64;
let f = b"src/foo.rs\0\0";
let rd = loc64(sv, f.len() as u64, 42, 9);
let bin = panic_bin(rd, sv, f.to_vec());
assert!(PanicsAnalyzer::new().analyze(&bin).is_empty());
}
#[test]
fn scan_finds_panic_in_comma_qualified_mach_sections() {
let sv = 0x4000u64;
let f = b"src/foo.rs";
let rd = loc64(sv, f.len() as u64, 42, 9);
let bin = Binary::from_test_parts(
Bf::MachO,
true,
true,
vec![
Section {
name: "__DATA_CONST.__const,regular".into(),
vaddr: 0x1000,
size: rd.len() as u64,
data: rd,
},
Section {
name: "__TEXT.__cstring,cstring_literals".into(),
vaddr: sv,
size: f.len() as u64,
data: f.to_vec(),
},
],
vec![],
vec![0, 1],
);
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_panic_in_exact_rodata1() {
let vaddr = 0x1000u64;
let file_vaddr = vaddr + 24;
let f = b"src/foo.rs";
let mut data = loc64(file_vaddr, f.len() as u64, 42, 9);
data.extend_from_slice(f);
let bin = Binary::from_test_parts(
Bf::Elf,
true,
true,
vec![Section {
name: ".rodata1".into(),
vaddr,
size: data.len() as u64,
data,
}],
vec![],
vec![0],
);
let anns = PanicsAnalyzer::new().analyze(&bin);
assert_eq!(anns.len(), 1);
assert_eq!(anns[0].label, "src/foo.rs:42:9");
}
#[test]
fn scan_honors_forced_string_section_classification() {
let sv = 0x4000u64;
let f = b"src/foo.rs";
let bin = Binary::from_test_parts(
Bf::Elf,
true,
true,
vec![
Section {
name: ".custom_locations".into(),
vaddr: 0x1000,
size: 24,
data: loc64(sv, f.len() as u64, 42, 9),
},
Section {
name: ".custom_files".into(),
vaddr: sv,
size: f.len() as u64,
data: f.to_vec(),
},
],
vec![],
vec![0, 1],
);
assert_eq!(PanicsAnalyzer::new().analyze(&bin).len(), 1);
}
#[test]
fn scan_does_not_override_an_empty_forced_classification() {
let sv = 0x4000u64;
let file = b"src/foo.rs";
let bin = Binary::from_test_parts(
Bf::Elf,
true,
true,
vec![
Section {
name: ".rodata".into(),
vaddr: 0x1000,
size: 24,
data: loc64(sv, file.len() as u64, 42, 9),
},
Section {
name: ".rodata.str".into(),
vaddr: sv,
size: file.len() as u64,
data: file.to_vec(),
},
],
vec![],
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.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![0, 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![0, 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![0, 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![0, 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![0, 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![0, 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![0, 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"
);
}
}