gsym-rs 0.1.6

Pure-Rust reader, writer, and Linux ELF/DWARF converter for LLVM GSYM
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105

use crate::endian::Endian;
use crate::format::line;
use crate::model::LineEntry;

use super::ENDIANS;

#[test]
fn line_table_handles_mixed_delta_and_same_address_rows() {
    let base = 0x1000;
    let lines = vec![
        LineEntry {
            address: base,
            file: 1.into(),
            line: 10,
        },
        LineEntry {
            address: base + 0x10,
            file: 1.into(),
            line: 11,
        },
        LineEntry {
            address: base + 0x100,
            file: 1.into(),
            line: 1000,
        },
        LineEntry {
            address: base + 0x120,
            file: 1.into(),
            line: 900,
        },
        LineEntry {
            address: base + 0x120,
            file: 2.into(),
            line: 2000,
        },
        LineEntry {
            address: base + 0x121,
            file: 2.into(),
            line: 2001,
        },
        LineEntry {
            address: base + 0x122,
            file: 2.into(),
            line: 2002,
        },
        LineEntry {
            address: base + 0x123,
            file: 2.into(),
            line: 2003,
        },
    ];
    for endian in ENDIANS {
        let bytes = line::encode(&lines, endian, base).unwrap();
        assert_eq!(line::decode(&bytes, endian, base).unwrap(), lines);
        assert_eq!(line::lookup(&bytes, endian, base, base - 1).unwrap(), None);
        assert_eq!(
            line::lookup(&bytes, endian, base, base + 0x11).unwrap(),
            lines.get(1).copied()
        );
        assert_eq!(
            line::lookup(&bytes, endian, base, base + 0x200).unwrap(),
            lines.last().copied()
        );
    }

    let little = line::encode(&lines, Endian::Little, base).unwrap();
    assert_eq!(line::decode(&little, Endian::Big, base).unwrap(), lines);
}

#[test]
fn line_table_reports_truncation_and_encode_errors() {
    let base = 0x1000;
    let lines = [
        LineEntry {
            address: base,
            file: 1.into(),
            line: 10,
        },
        LineEntry {
            address: base + 0x10,
            file: 1.into(),
            line: 11,
        },
    ];
    for endian in ENDIANS {
        let bytes = line::encode(&lines, endian, base).unwrap();
        for length in 0..bytes.len() {
            assert!(line::decode(bytes.split_at(length).0, endian, base).is_err());
        }
        assert!(line::encode(&[], endian, base).is_err());
        assert!(line::encode(&lines, endian, base + 1).is_err());
        assert!(line::encode(&[lines[1], lines[0]], endian, base).is_err());

        let malformed_programs: [&[u8]; 5] = [
            &[1],
            &[1, 10],
            &[1, 10, 20],
            &[1, 10, 20, 1],
            &[1, 10, 20, 1, 5, 2],
        ];
        for bytes in malformed_programs {
            assert!(line::decode(bytes, endian, base).is_err());
        }
    }
}