rustc_session/
filesearch.rs

1//! A module for searching for libraries
2
3use std::path::{Path, PathBuf};
4use std::{env, fs};
5
6use rustc_fs_util::{fix_windows_verbatim_for_gcc, try_canonicalize};
7use rustc_target::spec::Target;
8use smallvec::{SmallVec, smallvec};
9
10use crate::search_paths::{PathKind, SearchPath};
11
12#[derive(Clone)]
13pub struct FileSearch {
14    cli_search_paths: Vec<SearchPath>,
15    tlib_path: SearchPath,
16}
17
18impl FileSearch {
19    pub fn cli_search_paths<'b>(&'b self, kind: PathKind) -> impl Iterator<Item = &'b SearchPath> {
20        self.cli_search_paths.iter().filter(move |sp| sp.kind.matches(kind))
21    }
22
23    pub fn search_paths<'b>(&'b self, kind: PathKind) -> impl Iterator<Item = &'b SearchPath> {
24        self.cli_search_paths
25            .iter()
26            .filter(move |sp| sp.kind.matches(kind))
27            .chain(std::iter::once(&self.tlib_path))
28    }
29
30    pub fn new(cli_search_paths: &[SearchPath], tlib_path: &SearchPath, target: &Target) -> Self {
31        let this = FileSearch {
32            cli_search_paths: cli_search_paths.to_owned(),
33            tlib_path: tlib_path.clone(),
34        };
35        this.refine(&["lib", &target.staticlib_prefix, &target.dll_prefix])
36    }
37    // Produce a new file search from this search that has a smaller set of candidates.
38    fn refine(mut self, allowed_prefixes: &[&str]) -> FileSearch {
39        self.cli_search_paths
40            .iter_mut()
41            .for_each(|search_paths| search_paths.files.retain(allowed_prefixes));
42        self.tlib_path.files.retain(allowed_prefixes);
43
44        self
45    }
46}
47
48pub fn make_target_lib_path(sysroot: &Path, target_triple: &str) -> PathBuf {
49    let rustlib_path = rustc_target::relative_target_rustlib_path(sysroot, target_triple);
50    sysroot.join(rustlib_path).join("lib")
51}
52
53/// Returns a path to the target's `bin` folder within its `rustlib` path in the sysroot. This is
54/// where binaries are usually installed, e.g. the self-contained linkers, lld-wrappers, LLVM tools,
55/// etc.
56pub fn make_target_bin_path(sysroot: &Path, target_triple: &str) -> PathBuf {
57    let rustlib_path = rustc_target::relative_target_rustlib_path(sysroot, target_triple);
58    sysroot.join(rustlib_path).join("bin")
59}
60
61#[cfg(unix)]
62fn current_dll_path() -> Result<PathBuf, String> {
63    use std::sync::OnceLock;
64
65    // This is somewhat expensive relative to other work when compiling `fn main() {}` as `dladdr`
66    // needs to iterate over the symbol table of librustc_driver.so until it finds a match.
67    // As such cache this to avoid recomputing if we try to get the sysroot in multiple places.
68    static CURRENT_DLL_PATH: OnceLock<Result<PathBuf, String>> = OnceLock::new();
69    CURRENT_DLL_PATH
70        .get_or_init(|| {
71            use std::ffi::{CStr, OsStr};
72            use std::os::unix::prelude::*;
73
74            #[cfg(not(target_os = "aix"))]
75            unsafe {
76                let addr = current_dll_path as usize as *mut _;
77                let mut info = std::mem::zeroed();
78                if libc::dladdr(addr, &mut info) == 0 {
79                    return Err("dladdr failed".into());
80                }
81                #[cfg(target_os = "cygwin")]
82                let fname_ptr = info.dli_fname.as_ptr();
83                #[cfg(not(target_os = "cygwin"))]
84                let fname_ptr = {
85                    assert!(!info.dli_fname.is_null(), "dli_fname cannot be null");
86                    info.dli_fname
87                };
88                let bytes = CStr::from_ptr(fname_ptr).to_bytes();
89                let os = OsStr::from_bytes(bytes);
90                Ok(PathBuf::from(os))
91            }
92
93            #[cfg(target_os = "aix")]
94            unsafe {
95                // On AIX, the symbol `current_dll_path` references a function descriptor.
96                // A function descriptor is consisted of (See https://reviews.llvm.org/D62532)
97                // * The address of the entry point of the function.
98                // * The TOC base address for the function.
99                // * The environment pointer.
100                // The function descriptor is in the data section.
101                let addr = current_dll_path as u64;
102                let mut buffer = vec![std::mem::zeroed::<libc::ld_info>(); 64];
103                loop {
104                    if libc::loadquery(
105                        libc::L_GETINFO,
106                        buffer.as_mut_ptr() as *mut u8,
107                        (size_of::<libc::ld_info>() * buffer.len()) as u32,
108                    ) >= 0
109                    {
110                        break;
111                    } else {
112                        if std::io::Error::last_os_error().raw_os_error().unwrap() != libc::ENOMEM {
113                            return Err("loadquery failed".into());
114                        }
115                        buffer.resize(buffer.len() * 2, std::mem::zeroed::<libc::ld_info>());
116                    }
117                }
118                let mut current = buffer.as_mut_ptr() as *mut libc::ld_info;
119                loop {
120                    let data_base = (*current).ldinfo_dataorg as u64;
121                    let data_end = data_base + (*current).ldinfo_datasize;
122                    if (data_base..data_end).contains(&addr) {
123                        let bytes = CStr::from_ptr(&(*current).ldinfo_filename[0]).to_bytes();
124                        let os = OsStr::from_bytes(bytes);
125                        return Ok(PathBuf::from(os));
126                    }
127                    if (*current).ldinfo_next == 0 {
128                        break;
129                    }
130                    current = (current as *mut i8).offset((*current).ldinfo_next as isize)
131                        as *mut libc::ld_info;
132                }
133                return Err(format!("current dll's address {} is not in the load map", addr));
134            }
135        })
136        .clone()
137}
138
139#[cfg(windows)]
140fn current_dll_path() -> Result<PathBuf, String> {
141    use std::ffi::OsString;
142    use std::io;
143    use std::os::windows::prelude::*;
144
145    use windows::Win32::Foundation::HMODULE;
146    use windows::Win32::System::LibraryLoader::{
147        GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS, GetModuleFileNameW, GetModuleHandleExW,
148    };
149    use windows::core::PCWSTR;
150
151    let mut module = HMODULE::default();
152    unsafe {
153        GetModuleHandleExW(
154            GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS,
155            PCWSTR(current_dll_path as *mut u16),
156            &mut module,
157        )
158    }
159    .map_err(|e| e.to_string())?;
160
161    let mut filename = vec![0; 1024];
162    let n = unsafe { GetModuleFileNameW(Some(module), &mut filename) } as usize;
163    if n == 0 {
164        return Err(format!("GetModuleFileNameW failed: {}", io::Error::last_os_error()));
165    }
166    if n >= filename.capacity() {
167        return Err(format!("our buffer was too small? {}", io::Error::last_os_error()));
168    }
169
170    filename.truncate(n);
171
172    Ok(OsString::from_wide(&filename).into())
173}
174
175#[cfg(target_os = "wasi")]
176fn current_dll_path() -> Result<PathBuf, String> {
177    Err("current_dll_path is not supported on WASI".to_string())
178}
179
180pub fn sysroot_candidates() -> SmallVec<[PathBuf; 2]> {
181    let target = crate::config::host_tuple();
182    let mut sysroot_candidates: SmallVec<[PathBuf; 2]> = smallvec![get_or_default_sysroot()];
183    let path = current_dll_path().and_then(|s| try_canonicalize(s).map_err(|e| e.to_string()));
184    if let Ok(dll) = path {
185        // use `parent` twice to chop off the file name and then also the
186        // directory containing the dll which should be either `lib` or `bin`.
187        if let Some(path) = dll.parent().and_then(|p| p.parent()) {
188            // The original `path` pointed at the `rustc_driver` crate's dll.
189            // Now that dll should only be in one of two locations. The first is
190            // in the compiler's libdir, for example `$sysroot/lib/*.dll`. The
191            // other is the target's libdir, for example
192            // `$sysroot/lib/rustlib/$target/lib/*.dll`.
193            //
194            // We don't know which, so let's assume that if our `path` above
195            // ends in `$target` we *could* be in the target libdir, and always
196            // assume that we may be in the main libdir.
197            sysroot_candidates.push(path.to_owned());
198
199            if path.ends_with(target) {
200                sysroot_candidates.extend(
201                    path.parent() // chop off `$target`
202                        .and_then(|p| p.parent()) // chop off `rustlib`
203                        .and_then(|p| p.parent()) // chop off `lib`
204                        .map(|s| s.to_owned()),
205                );
206            }
207        }
208    }
209
210    sysroot_candidates
211}
212
213/// Returns the provided sysroot or calls [`get_or_default_sysroot`] if it's none.
214/// Panics if [`get_or_default_sysroot`]  returns an error.
215pub fn materialize_sysroot(maybe_sysroot: Option<PathBuf>) -> PathBuf {
216    maybe_sysroot.unwrap_or_else(|| get_or_default_sysroot())
217}
218
219/// This function checks if sysroot is found using env::args().next(), and if it
220/// is not found, finds sysroot from current rustc_driver dll.
221pub fn get_or_default_sysroot() -> PathBuf {
222    // Follow symlinks. If the resolved path is relative, make it absolute.
223    fn canonicalize(path: PathBuf) -> PathBuf {
224        let path = try_canonicalize(&path).unwrap_or(path);
225        // See comments on this target function, but the gist is that
226        // gcc chokes on verbatim paths which fs::canonicalize generates
227        // so we try to avoid those kinds of paths.
228        fix_windows_verbatim_for_gcc(&path)
229    }
230
231    fn default_from_rustc_driver_dll() -> Result<PathBuf, String> {
232        let dll = current_dll_path().map(|s| canonicalize(s))?;
233
234        // `dll` will be in one of the following two:
235        // - compiler's libdir: $sysroot/lib/*.dll
236        // - target's libdir: $sysroot/lib/rustlib/$target/lib/*.dll
237        //
238        // use `parent` twice to chop off the file name and then also the
239        // directory containing the dll
240        let dir = dll.parent().and_then(|p| p.parent()).ok_or(format!(
241            "Could not move 2 levels upper using `parent()` on {}",
242            dll.display()
243        ))?;
244
245        // if `dir` points target's dir, move up to the sysroot
246        let mut sysroot_dir = if dir.ends_with(crate::config::host_tuple()) {
247            dir.parent() // chop off `$target`
248                .and_then(|p| p.parent()) // chop off `rustlib`
249                .and_then(|p| p.parent()) // chop off `lib`
250                .map(|s| s.to_owned())
251                .ok_or_else(|| {
252                    format!("Could not move 3 levels upper using `parent()` on {}", dir.display())
253                })?
254        } else {
255            dir.to_owned()
256        };
257
258        // On multiarch linux systems, there will be multiarch directory named
259        // with the architecture(e.g `x86_64-linux-gnu`) under the `lib` directory.
260        // Which cause us to mistakenly end up in the lib directory instead of the sysroot directory.
261        if sysroot_dir.ends_with("lib") {
262            sysroot_dir =
263                sysroot_dir.parent().map(|real_sysroot| real_sysroot.to_owned()).ok_or_else(
264                    || format!("Could not move to parent path of {}", sysroot_dir.display()),
265                )?
266        }
267
268        Ok(sysroot_dir)
269    }
270
271    // Use env::args().next() to get the path of the executable without
272    // following symlinks/canonicalizing any component. This makes the rustc
273    // binary able to locate Rust libraries in systems using content-addressable
274    // storage (CAS).
275    fn from_env_args_next() -> Option<PathBuf> {
276        let mut p = PathBuf::from(env::args_os().next()?);
277
278        // Check if sysroot is found using env::args().next() only if the rustc in argv[0]
279        // is a symlink (see #79253). We might want to change/remove it to conform with
280        // https://www.gnu.org/prep/standards/standards.html#Finding-Program-Files in the
281        // future.
282        if fs::read_link(&p).is_err() {
283            // Path is not a symbolic link or does not exist.
284            return None;
285        }
286
287        // Pop off `bin/rustc`, obtaining the suspected sysroot.
288        p.pop();
289        p.pop();
290        // Look for the target rustlib directory in the suspected sysroot.
291        let mut rustlib_path = rustc_target::relative_target_rustlib_path(&p, "dummy");
292        rustlib_path.pop(); // pop off the dummy target.
293        rustlib_path.exists().then_some(p)
294    }
295
296    from_env_args_next().unwrap_or(default_from_rustc_driver_dll().expect("Failed finding sysroot"))
297}
rustc_session/filesearch.rs

rustc_session/
filesearch.rs
