264 lines
8.1 KiB
Rust
264 lines
8.1 KiB
Rust
// Copyright 2012-2013 The Rust Project Developers. See the COPYRIGHT
|
|
// file at the top-level directory of this distribution and at
|
|
// http://rust-lang.org/COPYRIGHT.
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
|
|
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
|
|
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
|
|
// option. This file may not be copied, modified, or distributed
|
|
// except according to those terms.
|
|
|
|
|
|
use driver::session::Session;
|
|
use metadata::cstore;
|
|
use metadata::filesearch;
|
|
use util::fs;
|
|
|
|
use collections::HashSet;
|
|
use std::os;
|
|
use syntax::abi;
|
|
|
|
fn not_win32(os: abi::Os) -> bool {
|
|
os != abi::OsWin32
|
|
}
|
|
|
|
pub fn get_rpath_flags(sess: &Session, out_filename: &Path) -> Vec<StrBuf> {
|
|
let os = sess.targ_cfg.os;
|
|
|
|
// No rpath on windows
|
|
if os == abi::OsWin32 {
|
|
return Vec::new();
|
|
}
|
|
|
|
let mut flags = Vec::new();
|
|
|
|
if sess.targ_cfg.os == abi::OsFreebsd {
|
|
flags.push_all(["-Wl,-rpath,/usr/local/lib/gcc46".to_strbuf(),
|
|
"-Wl,-rpath,/usr/local/lib/gcc44".to_strbuf(),
|
|
"-Wl,-z,origin".to_strbuf()]);
|
|
}
|
|
|
|
debug!("preparing the RPATH!");
|
|
|
|
let sysroot = sess.sysroot();
|
|
let output = out_filename;
|
|
let libs = sess.cstore.get_used_crates(cstore::RequireDynamic);
|
|
let libs = libs.move_iter().filter_map(|(_, l)| {
|
|
l.map(|p| p.clone())
|
|
}).collect::<Vec<_>>();
|
|
|
|
let rpaths = get_rpaths(os,
|
|
sysroot,
|
|
output,
|
|
libs.as_slice(),
|
|
sess.opts.target_triple.as_slice());
|
|
flags.push_all(rpaths_to_flags(rpaths.as_slice()).as_slice());
|
|
flags
|
|
}
|
|
|
|
pub fn rpaths_to_flags(rpaths: &[StrBuf]) -> Vec<StrBuf> {
|
|
let mut ret = Vec::new();
|
|
for rpath in rpaths.iter() {
|
|
ret.push(("-Wl,-rpath," + (*rpath).as_slice()).to_strbuf());
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
fn get_rpaths(os: abi::Os,
|
|
sysroot: &Path,
|
|
output: &Path,
|
|
libs: &[Path],
|
|
target_triple: &str) -> Vec<StrBuf> {
|
|
debug!("sysroot: {}", sysroot.display());
|
|
debug!("output: {}", output.display());
|
|
debug!("libs:");
|
|
for libpath in libs.iter() {
|
|
debug!(" {}", libpath.display());
|
|
}
|
|
debug!("target_triple: {}", target_triple);
|
|
|
|
// Use relative paths to the libraries. Binaries can be moved
|
|
// as long as they maintain the relative relationship to the
|
|
// crates they depend on.
|
|
let rel_rpaths = get_rpaths_relative_to_output(os, output, libs);
|
|
|
|
// And a final backup rpath to the global library location.
|
|
let fallback_rpaths = vec!(get_install_prefix_rpath(sysroot, target_triple));
|
|
|
|
fn log_rpaths(desc: &str, rpaths: &[StrBuf]) {
|
|
debug!("{} rpaths:", desc);
|
|
for rpath in rpaths.iter() {
|
|
debug!(" {}", *rpath);
|
|
}
|
|
}
|
|
|
|
log_rpaths("relative", rel_rpaths.as_slice());
|
|
log_rpaths("fallback", fallback_rpaths.as_slice());
|
|
|
|
let mut rpaths = rel_rpaths;
|
|
rpaths.push_all(fallback_rpaths.as_slice());
|
|
|
|
// Remove duplicates
|
|
let rpaths = minimize_rpaths(rpaths.as_slice());
|
|
return rpaths;
|
|
}
|
|
|
|
fn get_rpaths_relative_to_output(os: abi::Os,
|
|
output: &Path,
|
|
libs: &[Path]) -> Vec<StrBuf> {
|
|
libs.iter().map(|a| get_rpath_relative_to_output(os, output, a)).collect()
|
|
}
|
|
|
|
pub fn get_rpath_relative_to_output(os: abi::Os,
|
|
output: &Path,
|
|
lib: &Path)
|
|
-> StrBuf {
|
|
use std::os;
|
|
|
|
assert!(not_win32(os));
|
|
|
|
// Mac doesn't appear to support $ORIGIN
|
|
let prefix = match os {
|
|
abi::OsAndroid | abi::OsLinux | abi::OsFreebsd
|
|
=> "$ORIGIN",
|
|
abi::OsMacos => "@loader_path",
|
|
abi::OsWin32 => unreachable!()
|
|
};
|
|
|
|
let mut lib = fs::realpath(&os::make_absolute(lib)).unwrap();
|
|
lib.pop();
|
|
let mut output = fs::realpath(&os::make_absolute(output)).unwrap();
|
|
output.pop();
|
|
let relative = lib.path_relative_from(&output);
|
|
let relative = relative.expect("could not create rpath relative to output");
|
|
// FIXME (#9639): This needs to handle non-utf8 paths
|
|
(prefix + "/" + relative.as_str()
|
|
.expect("non-utf8 component in path")).to_strbuf()
|
|
}
|
|
|
|
pub fn get_install_prefix_rpath(sysroot: &Path, target_triple: &str) -> StrBuf {
|
|
let install_prefix = option_env!("CFG_PREFIX").expect("CFG_PREFIX");
|
|
|
|
let tlib = filesearch::relative_target_lib_path(sysroot, target_triple);
|
|
let mut path = Path::new(install_prefix);
|
|
path.push(&tlib);
|
|
let path = os::make_absolute(&path);
|
|
// FIXME (#9639): This needs to handle non-utf8 paths
|
|
path.as_str().expect("non-utf8 component in rpath").to_strbuf()
|
|
}
|
|
|
|
pub fn minimize_rpaths(rpaths: &[StrBuf]) -> Vec<StrBuf> {
|
|
let mut set = HashSet::new();
|
|
let mut minimized = Vec::new();
|
|
for rpath in rpaths.iter() {
|
|
if set.insert(rpath.as_slice()) {
|
|
minimized.push(rpath.clone());
|
|
}
|
|
}
|
|
minimized
|
|
}
|
|
|
|
#[cfg(unix, test)]
|
|
mod test {
|
|
use back::rpath::get_install_prefix_rpath;
|
|
use back::rpath::{minimize_rpaths, rpaths_to_flags, get_rpath_relative_to_output};
|
|
use syntax::abi;
|
|
use metadata::filesearch;
|
|
|
|
#[test]
|
|
fn test_rpaths_to_flags() {
|
|
let flags = rpaths_to_flags([
|
|
"path1".to_strbuf(),
|
|
"path2".to_strbuf()
|
|
]);
|
|
assert_eq!(flags,
|
|
vec!("-Wl,-rpath,path1".to_strbuf(),
|
|
"-Wl,-rpath,path2".to_strbuf()));
|
|
}
|
|
|
|
#[test]
|
|
fn test_prefix_rpath() {
|
|
let sysroot = filesearch::get_or_default_sysroot();
|
|
let res = get_install_prefix_rpath(&sysroot, "triple");
|
|
let mut d = Path::new((option_env!("CFG_PREFIX")).expect("CFG_PREFIX"));
|
|
d.push("lib");
|
|
d.push(filesearch::rustlibdir());
|
|
d.push("triple/lib");
|
|
debug!("test_prefix_path: {} vs. {}",
|
|
res,
|
|
d.display());
|
|
assert!(res.as_bytes().ends_with(d.as_vec()));
|
|
}
|
|
|
|
#[test]
|
|
fn test_prefix_rpath_abs() {
|
|
let sysroot = filesearch::get_or_default_sysroot();
|
|
let res = get_install_prefix_rpath(&sysroot, "triple");
|
|
assert!(Path::new(res).is_absolute());
|
|
}
|
|
|
|
#[test]
|
|
fn test_minimize1() {
|
|
let res = minimize_rpaths([
|
|
"rpath1".to_strbuf(),
|
|
"rpath2".to_strbuf(),
|
|
"rpath1".to_strbuf()
|
|
]);
|
|
assert!(res.as_slice() == [
|
|
"rpath1".to_strbuf(),
|
|
"rpath2".to_strbuf()
|
|
]);
|
|
}
|
|
|
|
#[test]
|
|
fn test_minimize2() {
|
|
let res = minimize_rpaths([
|
|
"1a".to_strbuf(),
|
|
"2".to_strbuf(),
|
|
"2".to_strbuf(),
|
|
"1a".to_strbuf(),
|
|
"4a".to_strbuf(),
|
|
"1a".to_strbuf(),
|
|
"2".to_strbuf(),
|
|
"3".to_strbuf(),
|
|
"4a".to_strbuf(),
|
|
"3".to_strbuf()
|
|
]);
|
|
assert!(res.as_slice() == [
|
|
"1a".to_strbuf(),
|
|
"2".to_strbuf(),
|
|
"4a".to_strbuf(),
|
|
"3".to_strbuf()
|
|
]);
|
|
}
|
|
|
|
#[test]
|
|
#[cfg(target_os = "linux")]
|
|
#[cfg(target_os = "android")]
|
|
fn test_rpath_relative() {
|
|
let o = abi::OsLinux;
|
|
let res = get_rpath_relative_to_output(o,
|
|
&Path::new("bin/rustc"), &Path::new("lib/libstd.so"));
|
|
assert_eq!(res.as_slice(), "$ORIGIN/../lib");
|
|
}
|
|
|
|
#[test]
|
|
#[cfg(target_os = "freebsd")]
|
|
fn test_rpath_relative() {
|
|
let o = abi::OsFreebsd;
|
|
let res = get_rpath_relative_to_output(o,
|
|
&Path::new("bin/rustc"), &Path::new("lib/libstd.so"));
|
|
assert_eq!(res.as_slice(), "$ORIGIN/../lib");
|
|
}
|
|
|
|
#[test]
|
|
#[cfg(target_os = "macos")]
|
|
fn test_rpath_relative() {
|
|
let o = abi::OsMacos;
|
|
let res = get_rpath_relative_to_output(o,
|
|
&Path::new("bin/rustc"),
|
|
&Path::new("lib/libstd.so"));
|
|
assert_eq!(res.as_slice(), "@loader_path/../lib");
|
|
}
|
|
}
|