mirror of
https://github.com/roc-lang/roc.git
synced 2025-09-28 06:14:46 +00:00
700 lines
22 KiB
Rust
700 lines
22 KiB
Rust
use crate::target::arch_str;
|
|
#[cfg(feature = "llvm")]
|
|
use libloading::{Error, Library};
|
|
#[cfg(feature = "llvm")]
|
|
use roc_mono::ir::OptLevel;
|
|
use std::collections::HashMap;
|
|
use std::env;
|
|
use std::io;
|
|
use std::path::{Path, PathBuf};
|
|
use std::process::{Child, Command, Output};
|
|
use target_lexicon::{Architecture, OperatingSystem, Triple};
|
|
|
|
#[derive(Debug, Copy, Clone, PartialEq, Eq)]
|
|
pub enum LinkType {
|
|
// These numbers correspond to the --lib flag; if it's present
|
|
// (e.g. is_present returns `1 as bool`), this will be 1 as well.
|
|
Executable = 0,
|
|
Dylib = 1,
|
|
}
|
|
|
|
/// input_paths can include the host as well as the app. e.g. &["host.o", "roc_app.o"]
|
|
pub fn link(
|
|
target: &Triple,
|
|
output_path: PathBuf,
|
|
input_paths: &[&str],
|
|
link_type: LinkType,
|
|
) -> io::Result<(Child, PathBuf)> {
|
|
match target {
|
|
Triple {
|
|
architecture: Architecture::Wasm32,
|
|
..
|
|
} => link_wasm32(target, output_path, input_paths, link_type),
|
|
Triple {
|
|
operating_system: OperatingSystem::Linux,
|
|
..
|
|
} => link_linux(target, output_path, input_paths, link_type),
|
|
Triple {
|
|
architecture: Architecture::X86_64,
|
|
operating_system: OperatingSystem::Darwin,
|
|
..
|
|
} => link_macos(target, output_path, input_paths, link_type),
|
|
_ => panic!("TODO gracefully handle unsupported target: {:?}", target),
|
|
}
|
|
}
|
|
|
|
fn find_zig_str_path() -> PathBuf {
|
|
let zig_str_path = PathBuf::from("compiler/builtins/bitcode/src/str.zig");
|
|
|
|
if std::path::Path::exists(&zig_str_path) {
|
|
return zig_str_path;
|
|
}
|
|
|
|
// when running the tests, we start in the /cli directory
|
|
let zig_str_path = PathBuf::from("../compiler/builtins/bitcode/src/str.zig");
|
|
if std::path::Path::exists(&zig_str_path) {
|
|
return zig_str_path;
|
|
}
|
|
|
|
panic!("cannot find `str.zig`")
|
|
}
|
|
|
|
#[cfg(not(target_os = "macos"))]
|
|
pub fn build_zig_host_native(
|
|
env_path: &str,
|
|
env_home: &str,
|
|
emit_bin: &str,
|
|
zig_host_src: &str,
|
|
zig_str_path: &str,
|
|
target: &str,
|
|
) -> Output {
|
|
Command::new("zig")
|
|
.env_clear()
|
|
.env("PATH", env_path)
|
|
.env("HOME", env_home)
|
|
.args(&[
|
|
"build-obj",
|
|
zig_host_src,
|
|
emit_bin,
|
|
"--pkg-begin",
|
|
"str",
|
|
zig_str_path,
|
|
"--pkg-end",
|
|
// include the zig runtime
|
|
"-fcompiler-rt",
|
|
// include libc
|
|
"--library",
|
|
"c",
|
|
// cross-compile?
|
|
"-target",
|
|
target,
|
|
])
|
|
.output()
|
|
.unwrap()
|
|
}
|
|
|
|
#[cfg(target_os = "macos")]
|
|
pub fn build_zig_host_native(
|
|
env_path: &str,
|
|
env_home: &str,
|
|
emit_bin: &str,
|
|
zig_host_src: &str,
|
|
zig_str_path: &str,
|
|
_target: &str,
|
|
) -> Output {
|
|
use serde_json::Value;
|
|
|
|
// Run `zig env` to find the location of zig's std/ directory
|
|
let zig_env_output = Command::new("zig").args(&["env"]).output().unwrap();
|
|
|
|
let zig_env_json = if zig_env_output.status.success() {
|
|
std::str::from_utf8(&zig_env_output.stdout).unwrap_or_else(|utf8_err| {
|
|
panic!(
|
|
"`zig env` failed; its stderr output was invalid utf8 ({:?})",
|
|
utf8_err
|
|
);
|
|
})
|
|
} else {
|
|
match std::str::from_utf8(&zig_env_output.stderr) {
|
|
Ok(stderr) => panic!("`zig env` failed - stderr output was: {:?}", stderr),
|
|
Err(utf8_err) => panic!(
|
|
"`zig env` failed; its stderr output was invalid utf8 ({:?})",
|
|
utf8_err
|
|
),
|
|
}
|
|
};
|
|
|
|
let mut zig_compiler_rt_path = match serde_json::from_str(zig_env_json) {
|
|
Ok(Value::Object(map)) => match map.get("std_dir") {
|
|
Some(Value::String(std_dir)) => PathBuf::from(Path::new(std_dir)),
|
|
_ => {
|
|
panic!("Expected JSON containing a `std_dir` String field from `zig env`, but got: {:?}", zig_env_json);
|
|
}
|
|
},
|
|
_ => {
|
|
panic!(
|
|
"Expected JSON containing a `std_dir` field from `zig env`, but got: {:?}",
|
|
zig_env_json
|
|
);
|
|
}
|
|
};
|
|
|
|
zig_compiler_rt_path.push("special");
|
|
zig_compiler_rt_path.push("compiler_rt.zig");
|
|
|
|
Command::new("zig")
|
|
.env_clear()
|
|
.env("PATH", &env_path)
|
|
.env("HOME", &env_home)
|
|
.args(&[
|
|
"build-obj",
|
|
zig_host_src,
|
|
emit_bin,
|
|
"--pkg-begin",
|
|
"str",
|
|
zig_str_path,
|
|
"--pkg-end",
|
|
// include the zig runtime
|
|
"--pkg-begin",
|
|
"compiler_rt",
|
|
zig_compiler_rt_path.to_str().unwrap(),
|
|
"--pkg-end",
|
|
// include libc
|
|
"--library",
|
|
"c",
|
|
])
|
|
.output()
|
|
.unwrap()
|
|
}
|
|
|
|
pub fn build_zig_host_wasm32(
|
|
env_path: &str,
|
|
env_home: &str,
|
|
emit_bin: &str,
|
|
zig_host_src: &str,
|
|
zig_str_path: &str,
|
|
) -> Output {
|
|
// NOTE currently just to get compiler warnings if the host code is invalid.
|
|
// the produced artifact is not used
|
|
//
|
|
// NOTE we're emitting LLVM IR here (again, it is not actually used)
|
|
//
|
|
// we'd like to compile with `-target wasm32-wasi` but that is blocked on
|
|
//
|
|
// https://github.com/ziglang/zig/issues/9414
|
|
Command::new("zig")
|
|
.env_clear()
|
|
.env("PATH", env_path)
|
|
.env("HOME", env_home)
|
|
.args(&[
|
|
"build-obj",
|
|
zig_host_src,
|
|
emit_bin,
|
|
"--pkg-begin",
|
|
"str",
|
|
zig_str_path,
|
|
"--pkg-end",
|
|
// include the zig runtime
|
|
// "-fcompiler-rt",
|
|
// include libc
|
|
"--library",
|
|
"c",
|
|
"-target",
|
|
"i386-linux-musl",
|
|
// "wasm32-wasi",
|
|
// "-femit-llvm-ir=/home/folkertdev/roc/roc/examples/benchmarks/platform/host.ll",
|
|
])
|
|
.output()
|
|
.unwrap()
|
|
}
|
|
|
|
pub fn rebuild_host(target: &Triple, host_input_path: &Path) {
|
|
let c_host_src = host_input_path.with_file_name("host.c");
|
|
let c_host_dest = host_input_path.with_file_name("c_host.o");
|
|
let zig_host_src = host_input_path.with_file_name("host.zig");
|
|
let rust_host_src = host_input_path.with_file_name("host.rs");
|
|
let rust_host_dest = host_input_path.with_file_name("rust_host.o");
|
|
let cargo_host_src = host_input_path.with_file_name("Cargo.toml");
|
|
let host_dest_native = host_input_path.with_file_name("host.o");
|
|
let host_dest_wasm = host_input_path.with_file_name("host.bc");
|
|
|
|
let env_path = env::var("PATH").unwrap_or_else(|_| "".to_string());
|
|
let env_home = env::var("HOME").unwrap_or_else(|_| "".to_string());
|
|
|
|
if zig_host_src.exists() {
|
|
// Compile host.zig
|
|
|
|
let zig_str_path = find_zig_str_path();
|
|
|
|
debug_assert!(
|
|
std::path::Path::exists(&zig_str_path),
|
|
"Cannot find str.zig, looking at {:?}",
|
|
&zig_str_path
|
|
);
|
|
|
|
let output = match target.architecture {
|
|
Architecture::Wasm32 => {
|
|
let emit_bin = format!("-femit-llvm-ir={}", host_dest_wasm.to_str().unwrap());
|
|
build_zig_host_wasm32(
|
|
&env_path,
|
|
&env_home,
|
|
&emit_bin,
|
|
zig_host_src.to_str().unwrap(),
|
|
zig_str_path.to_str().unwrap(),
|
|
)
|
|
}
|
|
Architecture::X86_64 => {
|
|
let emit_bin = format!("-femit-bin={}", host_dest_native.to_str().unwrap());
|
|
build_zig_host_native(
|
|
&env_path,
|
|
&env_home,
|
|
&emit_bin,
|
|
zig_host_src.to_str().unwrap(),
|
|
zig_str_path.to_str().unwrap(),
|
|
"native",
|
|
)
|
|
}
|
|
Architecture::X86_32(_) => {
|
|
let emit_bin = format!("-femit-bin={}", host_dest_native.to_str().unwrap());
|
|
build_zig_host_native(
|
|
&env_path,
|
|
&env_home,
|
|
&emit_bin,
|
|
zig_host_src.to_str().unwrap(),
|
|
zig_str_path.to_str().unwrap(),
|
|
"i386-linux-musl",
|
|
)
|
|
}
|
|
_ => panic!("Unsupported architecture {:?}", target.architecture),
|
|
};
|
|
|
|
validate_output("host.zig", "zig", output)
|
|
} else {
|
|
// Compile host.c
|
|
let output = Command::new("clang")
|
|
.env_clear()
|
|
.env("PATH", &env_path)
|
|
.args(&[
|
|
"-c",
|
|
c_host_src.to_str().unwrap(),
|
|
"-o",
|
|
c_host_dest.to_str().unwrap(),
|
|
])
|
|
.output()
|
|
.unwrap();
|
|
|
|
validate_output("host.c", "clang", output);
|
|
}
|
|
|
|
if cargo_host_src.exists() {
|
|
// Compile and link Cargo.toml, if it exists
|
|
let cargo_dir = host_input_path.parent().unwrap();
|
|
let libhost_dir = cargo_dir.join("target").join("release");
|
|
|
|
let output = Command::new("cargo")
|
|
.args(&["build", "--release"])
|
|
.current_dir(cargo_dir)
|
|
.output()
|
|
.unwrap();
|
|
|
|
validate_output("src/lib.rs", "cargo build --release", output);
|
|
|
|
let output = Command::new("ld")
|
|
.env_clear()
|
|
.env("PATH", &env_path)
|
|
.args(&[
|
|
"-r",
|
|
"-L",
|
|
libhost_dir.to_str().unwrap(),
|
|
c_host_dest.to_str().unwrap(),
|
|
"-lhost",
|
|
"-o",
|
|
host_dest_native.to_str().unwrap(),
|
|
])
|
|
.output()
|
|
.unwrap();
|
|
|
|
validate_output("c_host.o", "ld", output);
|
|
} else if rust_host_src.exists() {
|
|
// Compile and link host.rs, if it exists
|
|
let output = Command::new("rustc")
|
|
.args(&[
|
|
rust_host_src.to_str().unwrap(),
|
|
"-o",
|
|
rust_host_dest.to_str().unwrap(),
|
|
])
|
|
.output()
|
|
.unwrap();
|
|
|
|
validate_output("host.rs", "rustc", output);
|
|
|
|
let output = Command::new("ld")
|
|
.env_clear()
|
|
.env("PATH", &env_path)
|
|
.args(&[
|
|
"-r",
|
|
c_host_dest.to_str().unwrap(),
|
|
rust_host_dest.to_str().unwrap(),
|
|
"-o",
|
|
host_dest_native.to_str().unwrap(),
|
|
])
|
|
.output()
|
|
.unwrap();
|
|
|
|
validate_output("rust_host.o", "ld", output);
|
|
|
|
// Clean up rust_host.o
|
|
let output = Command::new("rm")
|
|
.env_clear()
|
|
.args(&[
|
|
"-f",
|
|
rust_host_dest.to_str().unwrap(),
|
|
c_host_dest.to_str().unwrap(),
|
|
])
|
|
.output()
|
|
.unwrap();
|
|
|
|
validate_output("rust_host.o", "rm", output);
|
|
} else if c_host_dest.exists() {
|
|
// Clean up c_host.o
|
|
let output = Command::new("mv")
|
|
.env_clear()
|
|
.args(&[c_host_dest, host_dest_native])
|
|
.output()
|
|
.unwrap();
|
|
|
|
validate_output("c_host.o", "mv", output);
|
|
}
|
|
}
|
|
|
|
fn nixos_path() -> String {
|
|
env::var("NIXOS_GLIBC_PATH").unwrap_or_else(|_| {
|
|
panic!(
|
|
"We couldn't find glibc! We tried looking for NIXOS_GLIBC_PATH
|
|
to find it via Nix, but that didn't work either. Please file a bug report.
|
|
|
|
This will only be an issue until we implement surgical linking.",
|
|
)
|
|
})
|
|
}
|
|
|
|
fn library_path<const N: usize>(segments: [&str; N]) -> Option<PathBuf> {
|
|
let mut guess_path = PathBuf::new();
|
|
for s in segments {
|
|
guess_path.push(s);
|
|
}
|
|
if guess_path.exists() {
|
|
Some(guess_path)
|
|
} else {
|
|
None
|
|
}
|
|
}
|
|
|
|
fn link_linux(
|
|
target: &Triple,
|
|
output_path: PathBuf,
|
|
input_paths: &[&str],
|
|
link_type: LinkType,
|
|
) -> io::Result<(Child, PathBuf)> {
|
|
let architecture = format!("{}-linux-gnu", target.architecture);
|
|
|
|
// Command::new("cp")
|
|
// .args(&[input_paths[0], "/home/folkertdev/roc/wasm/host.o"])
|
|
// .output()
|
|
// .unwrap();
|
|
//
|
|
// Command::new("cp")
|
|
// .args(&[input_paths[1], "/home/folkertdev/roc/wasm/app.o"])
|
|
// .output()
|
|
// .unwrap();
|
|
|
|
if let Architecture::X86_32(_) = target.architecture {
|
|
return Ok((
|
|
Command::new("zig")
|
|
.args(&["build-exe"])
|
|
.args(input_paths)
|
|
.args(&[
|
|
"-target",
|
|
"i386-linux-musl",
|
|
"-lc",
|
|
&format!("-femit-bin={}", output_path.to_str().unwrap()),
|
|
])
|
|
.spawn()?,
|
|
output_path,
|
|
));
|
|
}
|
|
|
|
let libcrt_path = library_path(["/usr", "lib", &architecture])
|
|
.or_else(|| library_path(["/usr", "lib"]))
|
|
.or_else(|| library_path([&nixos_path()]))
|
|
.unwrap();
|
|
|
|
let libgcc_name = "libgcc_s.so.1";
|
|
let libgcc_path = library_path(["/lib", &architecture, libgcc_name])
|
|
.or_else(|| library_path(["/usr", "lib", &architecture, libgcc_name]))
|
|
.or_else(|| library_path(["/usr", "lib", libgcc_name]))
|
|
.or_else(|| library_path([&nixos_path(), libgcc_name]))
|
|
.unwrap();
|
|
|
|
let ld_linux = match target.architecture {
|
|
Architecture::X86_64 => library_path(["/lib64", "ld-linux-x86-64.so.2"])
|
|
.or_else(|| library_path([&nixos_path(), "ld-linux-x86-64.so.2"])),
|
|
Architecture::Aarch64(_) => library_path(["/lib", "ld-linux-aarch64.so.1"]),
|
|
_ => panic!(
|
|
"TODO gracefully handle unsupported linux architecture: {:?}",
|
|
target.architecture
|
|
),
|
|
};
|
|
let ld_linux = ld_linux.unwrap();
|
|
let ld_linux = ld_linux.to_str().unwrap();
|
|
|
|
let mut soname;
|
|
let (base_args, output_path) = match link_type {
|
|
LinkType::Executable => (
|
|
// Presumably this S stands for Static, since if we include Scrt1.o
|
|
// in the linking for dynamic builds, linking fails.
|
|
vec![libcrt_path.join("Scrt1.o").to_str().unwrap().to_string()],
|
|
output_path,
|
|
),
|
|
LinkType::Dylib => {
|
|
// TODO: do we actually need the version number on this?
|
|
// Do we even need the "-soname" argument?
|
|
//
|
|
// See https://software.intel.com/content/www/us/en/develop/articles/create-a-unix-including-linux-shared-library.html
|
|
|
|
soname = output_path.clone();
|
|
soname.set_extension("so.1");
|
|
|
|
let mut output_path = output_path;
|
|
|
|
output_path.set_extension("so.1.0");
|
|
|
|
(
|
|
// TODO: find a way to avoid using a vec! here - should theoretically be
|
|
// able to do this somehow using &[] but the borrow checker isn't having it.
|
|
// Also find a way to have these be string slices instead of Strings.
|
|
vec![
|
|
"-shared".to_string(),
|
|
"-soname".to_string(),
|
|
soname.as_path().to_str().unwrap().to_string(),
|
|
],
|
|
output_path,
|
|
)
|
|
}
|
|
};
|
|
|
|
let env_path = env::var("PATH").unwrap_or_else(|_| "".to_string());
|
|
|
|
init_arch(target);
|
|
|
|
// NOTE: order of arguments to `ld` matters here!
|
|
// The `-l` flags should go after the `.o` arguments
|
|
Ok((
|
|
Command::new("ld")
|
|
// Don't allow LD_ env vars to affect this
|
|
.env_clear()
|
|
.env("PATH", &env_path)
|
|
// Keep NIX_ env vars
|
|
.envs(
|
|
env::vars()
|
|
.filter(|&(ref k, _)| k.starts_with("NIX_"))
|
|
.collect::<HashMap<String, String>>(),
|
|
)
|
|
.args(&[
|
|
"--gc-sections",
|
|
"--eh-frame-hdr",
|
|
"-arch",
|
|
arch_str(target),
|
|
libcrt_path.join("crti.o").to_str().unwrap(),
|
|
libcrt_path.join("crtn.o").to_str().unwrap(),
|
|
])
|
|
.args(&base_args)
|
|
.args(&["-dynamic-linker", ld_linux])
|
|
.args(input_paths)
|
|
// ld.lld requires this argument, and does not accept -arch
|
|
// .args(&["-L/usr/lib/x86_64-linux-gnu"])
|
|
.args(&[
|
|
// Libraries - see https://github.com/rtfeldman/roc/pull/554#discussion_r496365925
|
|
// for discussion and further references
|
|
"-lc",
|
|
"-lm",
|
|
"-lpthread",
|
|
"-ldl",
|
|
"-lrt",
|
|
"-lutil",
|
|
"-lc_nonshared",
|
|
libgcc_path.to_str().unwrap(),
|
|
// Output
|
|
"-o",
|
|
output_path.as_path().to_str().unwrap(), // app (or app.so or app.dylib etc.)
|
|
])
|
|
.spawn()?,
|
|
output_path,
|
|
))
|
|
}
|
|
|
|
fn link_macos(
|
|
target: &Triple,
|
|
output_path: PathBuf,
|
|
input_paths: &[&str],
|
|
link_type: LinkType,
|
|
) -> io::Result<(Child, PathBuf)> {
|
|
let (link_type_arg, output_path) = match link_type {
|
|
LinkType::Executable => ("-execute", output_path),
|
|
LinkType::Dylib => {
|
|
let mut output_path = output_path;
|
|
|
|
output_path.set_extension("dylib");
|
|
|
|
("-dylib", output_path)
|
|
}
|
|
};
|
|
|
|
// This path only exists on macOS Big Sur, and it causes ld errors
|
|
// on Catalina if it's specified with -L, so we replace it with a
|
|
// redundant -lSystem if the directory isn't there.
|
|
let big_sur_path = "/Library/Developer/CommandLineTools/SDKs/MacOSX.sdk/usr/lib";
|
|
let big_sur_fix = if Path::new(big_sur_path).exists() {
|
|
format!("-L{}", big_sur_path)
|
|
} else {
|
|
String::from("-lSystem")
|
|
};
|
|
|
|
Ok((
|
|
// NOTE: order of arguments to `ld` matters here!
|
|
// The `-l` flags should go after the `.o` arguments
|
|
Command::new("ld")
|
|
// Don't allow LD_ env vars to affect this
|
|
.env_clear()
|
|
.args(&[
|
|
// NOTE: we don't do --gc-sections on macOS because the default
|
|
// macOS linker doesn't support it, but it's a performance
|
|
// optimization, so if we ever switch to a different linker,
|
|
// we'd like to re-enable it on macOS!
|
|
// "--gc-sections",
|
|
link_type_arg,
|
|
"-arch",
|
|
target.architecture.to_string().as_str(),
|
|
])
|
|
.args(input_paths)
|
|
.args(&[
|
|
// Libraries - see https://github.com/rtfeldman/roc/pull/554#discussion_r496392274
|
|
// for discussion and further references
|
|
&big_sur_fix,
|
|
"-lSystem",
|
|
"-lresolv",
|
|
"-lpthread",
|
|
// "-lrt", // TODO shouldn't we need this?
|
|
// "-lc_nonshared", // TODO shouldn't we need this?
|
|
// "-lgcc", // TODO will eventually need compiler_rt from gcc or something - see https://github.com/rtfeldman/roc/pull/554#discussion_r496370840
|
|
// "-framework", // Uncomment this line & the following ro run the `rand` crate in examples/cli
|
|
// "Security",
|
|
// Output
|
|
"-o",
|
|
output_path.to_str().unwrap(), // app
|
|
])
|
|
.spawn()?,
|
|
output_path,
|
|
))
|
|
}
|
|
|
|
fn link_wasm32(
|
|
_target: &Triple,
|
|
output_path: PathBuf,
|
|
input_paths: &[&str],
|
|
_link_type: LinkType,
|
|
) -> io::Result<(Child, PathBuf)> {
|
|
let zig_str_path = find_zig_str_path();
|
|
|
|
let child = Command::new("zig9")
|
|
// .env_clear()
|
|
// .env("PATH", &env_path)
|
|
.args(&["build-exe"])
|
|
.args(input_paths)
|
|
.args([
|
|
&format!("-femit-bin={}", output_path.to_str().unwrap()),
|
|
// include libc
|
|
"-lc",
|
|
"-target",
|
|
"wasm32-wasi-musl",
|
|
"--pkg-begin",
|
|
"str",
|
|
zig_str_path.to_str().unwrap(),
|
|
"--pkg-end",
|
|
"--strip",
|
|
// "-O", "ReleaseSmall",
|
|
// useful for debugging
|
|
// "-femit-llvm-ir=/home/folkertdev/roc/roc/examples/benchmarks/platform/host.ll",
|
|
])
|
|
.spawn()?;
|
|
|
|
Ok((child, output_path))
|
|
}
|
|
|
|
#[cfg(feature = "llvm")]
|
|
pub fn module_to_dylib(
|
|
module: &inkwell::module::Module,
|
|
target: &Triple,
|
|
opt_level: OptLevel,
|
|
) -> Result<Library, Error> {
|
|
use crate::target::{self, convert_opt_level};
|
|
use inkwell::targets::{CodeModel, FileType, RelocMode};
|
|
|
|
let dir = tempfile::tempdir().unwrap();
|
|
let filename = PathBuf::from("Test.roc");
|
|
let file_path = dir.path().join(filename);
|
|
let mut app_o_file = file_path;
|
|
|
|
app_o_file.set_file_name("app.o");
|
|
|
|
// Emit the .o file using position-independent code (PIC) - needed for dylibs
|
|
let reloc = RelocMode::PIC;
|
|
let model = CodeModel::Default;
|
|
let target_machine =
|
|
target::target_machine(target, convert_opt_level(opt_level), reloc, model).unwrap();
|
|
|
|
target_machine
|
|
.write_to_file(module, FileType::Object, &app_o_file)
|
|
.expect("Writing .o file failed");
|
|
|
|
// Link app.o into a dylib - e.g. app.so or app.dylib
|
|
let (mut child, dylib_path) = link(
|
|
&Triple::host(),
|
|
app_o_file.clone(),
|
|
&[app_o_file.to_str().unwrap()],
|
|
LinkType::Dylib,
|
|
)
|
|
.unwrap();
|
|
|
|
child.wait().unwrap();
|
|
|
|
// Load the dylib
|
|
let path = dylib_path.as_path().to_str().unwrap();
|
|
|
|
Library::new(path)
|
|
}
|
|
|
|
fn validate_output(file_name: &str, cmd_name: &str, output: Output) {
|
|
if !output.status.success() {
|
|
match std::str::from_utf8(&output.stderr) {
|
|
Ok(stderr) => panic!(
|
|
"Failed to rebuild {} - stderr of the `{}` command was:\n{}",
|
|
file_name, cmd_name, stderr
|
|
),
|
|
Err(utf8_err) => panic!(
|
|
"Failed to rebuild {} - stderr of the `{}` command was invalid utf8 ({:?})",
|
|
file_name, cmd_name, utf8_err
|
|
),
|
|
}
|
|
}
|
|
}
|
|
|
|
#[cfg(feature = "llvm")]
|
|
fn init_arch(target: &Triple) {
|
|
crate::target::init_arch(target);
|
|
}
|
|
|
|
#[cfg(not(feature = "llvm"))]
|
|
fn init_arch(_target: &Triple) {
|
|
panic!("Tried to initialize LLVM when crate was not built with `feature = \"llvm\"` enabled");
|
|
}
|