qld 0.1.1

A fast, parallel linker compatible with GNU ld, gold, lld and mold
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

//! Exported weak definitions in legacy (`LC_DYLD_INFO_ONLY`) output: the
//! references are rebased to the image's own definition and listed in the
//! weak binding stream, sorted by name, as ld64 and `ld64.lld` do, so that
//! dyld coalesces them across images (C++ type information, inline
//! functions' static locals).

use std::collections::BTreeSet;

use super::{clang_for, ld64_lld, link_bytes, objdump, os, scratch, skip, syslibroot, tool_works};

const SOURCE: &str = "\
__attribute__((weak)) int shared_value = 3;
__attribute__((weak)) int weak_function(void) { return 1; }
int (*const function_pointer)(void) = weak_function;
int *value_pointer = &shared_value;
int use_them(void) { return weak_function() + shared_value + *value_pointer; }
";

/// `(symbol, section)` of each weak binding `llvm-objdump` lists.
fn weak_binds(file: &std::path::Path) -> Option<BTreeSet<(String, String)>> {
    let text = objdump(&["--macho", "--weak-bind"], file)?;
    Some(
        text.lines()
            .filter_map(|line| {
                let fields: Vec<&str> = line.split_whitespace().collect();
                // segment section address type addend symbol
                let symbol = fields.last()?;
                let section = fields.get(1)?;
                symbol
                    .starts_with('_')
                    .then(|| ((*symbol).to_owned(), (*section).to_owned()))
            })
            .collect(),
    )
}

#[test]
fn legacy_weak_binding() {
    for arch in ["arm64", "x86_64"] {
        if !clang_for(arch) {
            skip(
                "legacy_weak_binding",
                &format!("clang cannot target {arch}-apple-macos"),
            );
            continue;
        }
        let dir = scratch("legacy_weak");
        let source = dir.join("weak.c");
        std::fs::write(&source, SOURCE).unwrap();
        let object = dir.join(format!("weak-{arch}.o"));
        assert!(tool_works(
            "clang",
            &[
                &format!("--target={arch}-apple-macos11"),
                "-O1",
                "-c",
                source.to_str().unwrap(),
                "-o",
                object.to_str().unwrap(),
            ]
        ));
        let root = syslibroot();
        let args = os(&[
            "-arch",
            arch,
            "-dylib",
            "-platform_version",
            "macos",
            "11.0",
            "11.0",
            "-syslibroot",
            root.to_str().unwrap(),
            object.to_str().unwrap(),
            "-lSystem",
        ]);
        let (bytes, _) = link_bytes(&args).unwrap();
        let ours = dir.join(format!("libweak-{arch}.dylib"));
        std::fs::write(&ours, &bytes).unwrap();

        let Some(binds) = weak_binds(&ours) else {
            skip("legacy_weak_binding", "llvm-objdump is not installed");
            continue;
        };
        let names: BTreeSet<&str> = binds.iter().map(|(s, _)| s.as_str()).collect();
        assert_eq!(
            names,
            BTreeSet::from(["_shared_value", "_weak_function"]),
            "{arch}: {binds:?}"
        );
        // No ordinary bind for them: they are rebased to this image.
        let bind = objdump(&["--macho", "--bind"], &ours).unwrap_or_default();
        assert!(!bind.contains("_weak_function"), "{arch}: {bind}");

        if let Some(lld) = ld64_lld() {
            let theirs = dir.join(format!("libweak-{arch}-lld.dylib"));
            let status = std::process::Command::new(lld)
                .args(&args)
                .arg("-o")
                .arg(&theirs)
                .status()
                .unwrap();
            assert!(status.success());
            let reference = weak_binds(&theirs).unwrap();
            let reference_names: BTreeSet<&str> =
                reference.iter().map(|(s, _)| s.as_str()).collect();
            assert_eq!(names, reference_names, "{arch}: qld vs ld64.lld");
        }
    }
}