object 0.39.1

A unified interface for reading and writing object file formats.
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
106
107
108
109
110
111

#[cfg(feature = "std")]
use object::{Object, ObjectSection as _};

// Test that entry points are correctly extracted from both LC_MAIN and LC_UNIXTHREAD.
#[cfg(feature = "std")]
#[test]
fn test_macho_entry_point() {
    let macho_testfiles = std::path::Path::new("testfiles/macho");

    // go-x86_64 uses LC_UNIXTHREAD (legacy thread command with register state)
    let path = macho_testfiles.join("go-x86_64");
    let file = std::fs::File::open(&path).unwrap();
    let reader = object::read::ReadCache::new(file);
    let object = object::read::File::parse(&reader).unwrap();
    assert_eq!(
        object.entry(),
        0x10637e0,
        "go-x86_64: entry point from LC_UNIXTHREAD"
    );

    // base-x86_64 uses LC_MAIN (modern entry point command)
    let path = macho_testfiles.join("base-x86_64");
    let file = std::fs::File::open(&path).unwrap();
    let reader = object::read::ReadCache::new(file);
    let object = object::read::File::parse(&reader).unwrap();
    assert_eq!(
        object.entry(),
        0x3f60, // entryoff from LC_MAIN
        "base-x86_64: entry point from LC_MAIN"
    );

    // go-aarch64 uses LC_MAIN (not LC_UNIXTHREAD like go-x86_64)
    let path = macho_testfiles.join("go-aarch64");
    let file = std::fs::File::open(&path).unwrap();
    let reader = object::read::ReadCache::new(file);
    let object = object::read::File::parse(&reader).unwrap();
    assert_eq!(
        object.entry(),
        0x64450, // entryoff from LC_MAIN
        "go-aarch64: entry point from LC_MAIN"
    );

    // static-aarch64 uses LC_UNIXTHREAD (static binary with thread command)
    let path = macho_testfiles.join("static-aarch64");
    let file = std::fs::File::open(&path).unwrap();
    let reader = object::read::ReadCache::new(file);
    let object = object::read::File::parse(&reader).unwrap();
    assert_eq!(
        object.entry(),
        0x1000002f0, // pc from LC_UNIXTHREAD
        "static-aarch64: entry point from LC_UNIXTHREAD"
    );

    // static-x86 uses LC_UNIXTHREAD (32-bit static binary)
    let path = macho_testfiles.join("static-x86");
    let file = std::fs::File::open(&path).unwrap();
    let reader = object::read::ReadCache::new(file);
    let object = object::read::File::parse(&reader).unwrap();
    assert_eq!(
        object.entry(),
        0x1ff0, // eip from LC_UNIXTHREAD
        "static-x86: entry point from LC_UNIXTHREAD"
    );
}

// Test that we can read compressed sections in Mach-O files as produced
// by the Go compiler.
#[cfg(feature = "std")]
#[test]
fn test_go_macho() {
    let macho_testfiles = std::path::Path::new("testfiles/macho");

    // Section names we expect to find, whether they should be
    // compressed, and the actual name of the section in the file.
    const EXPECTED: &[(&str, bool, &str)] = &[
        (".debug_abbrev", true, "__zdebug_abbrev"),
        (".debug_gdb_scripts", false, "__debug_gdb_scri"),
        (".debug_ranges", true, "__zdebug_ranges"),
        ("__data", false, "__data"),
    ];

    for file in &["go-aarch64", "go-x86_64"] {
        let path = macho_testfiles.join(file);
        let file = std::fs::File::open(path).unwrap();
        let reader = object::read::ReadCache::new(file);
        let object = object::read::File::parse(&reader).unwrap();
        for &(name, compressed, actual_name) in EXPECTED {
            let section = object.section_by_name(name).unwrap();
            assert_eq!(section.name(), Ok(actual_name));
            let compressed_file_range = section.compressed_file_range().unwrap();
            let size = section.size();
            if compressed {
                assert_eq!(
                    compressed_file_range.format,
                    object::CompressionFormat::Zlib
                );
                assert_eq!(compressed_file_range.compressed_size, size - 12);
                assert!(
                    compressed_file_range.uncompressed_size > compressed_file_range.compressed_size,
                    "decompressed size is greater than compressed size"
                );
            } else {
                assert_eq!(
                    compressed_file_range.format,
                    object::CompressionFormat::None
                );
                assert_eq!(compressed_file_range.compressed_size, size);
            }
        }
    }
}