pezkuwichain/revive
1
0
Fork 0
mirror of https://github.com/pezkuwichain/revive.git synced 2026-06-13 20:01:04 +00:00
Code Issues Packages Projects Releases Wiki Activity

revive llvm builder utility (#154)

Browse Source 
Pre-eliminary support for LLVM releases and resolc binary releases by streamlining the build process for all supported hosts platforms.

- Introduce the revive-llvm-builder crate with the revive-llvm builder utilty.
- Do not rely on the LLVM dependency in $PATH to decouple the system LLVM installation from the LLVM host dependency.
- Fix the emscripten build by decoupling the host and native LLVM dependencies. Thus allowing a single LLVM emscripten release that can be used on any host platform.
- An example Dockerfile building an alpine container with a fully statically linked resolc ELF binary.
- Remove the Debian builder utilities and workflow.
This commit is contained in:
Cyrill Leutwiler
2025-01-13 15:58:27 +01:00
committed by GitHub
parent fde9edab10
commit 7f81f37e0c
65 changed files with 4847 additions and 557 deletions
Download Patch File Download Diff File Expand all files Collapse all files
crates/build-utils/.gitignore
+14
View File
@@ -0,0 +1,14 @@
# Generated by Cargo
# will have compiled files and executables
/target/
# Remove Cargo.lock from gitignore if creating an executable, leave it for libraries
# More information here https://doc.rust-lang.org/cargo/guide/cargo-toml-vs-cargo-lock.html
Cargo.lock
# These are backup files generated by rustfmt
**/*.rs.bk
# IDE
/.idea/
/.vscode/
crates/build-utils/Cargo.toml
+15
View File
@@ -0,0 +1,15 @@
[package]
name = "revive-build-utils"
version.workspace = true
license.workspace = true
edition.workspace = true
repository.workspace = true
authors = [
"Cyrill Leutwiler <cyrill@parity.io>",
]
description = "Shared build utilities of the revive compiler"
[lib]
doctest = false
[dependencies]
crates/build-utils/README.md
+10
View File
@@ -0,0 +1,10 @@
# revive: Compiler Common
## License
This library is distributed under the terms of either
- Apache License, Version 2.0, ([LICENSE-APACHE](LICENSE-APACHE) or <http://www.apache.org/licenses/LICENSE-2.0>)
- MIT license ([LICENSE-MIT](LICENSE-MIT) or <http://opensource.org/licenses/MIT>)
at your option.
crates/build-utils/src/lib.rs
+48
View File
@@ -0,0 +1,48 @@
//! The compiler build utilities library.
/// The revive LLVM host dependency directory prefix environment variable.
pub const REVIVE_LLVM_HOST_PREFIX: &str = "LLVM_SYS_181_PREFIX";
/// The revive LLVM target dependency directory prefix environment variable.
pub const REVIVE_LLVM_TARGET_PREFIX: &str = "REVIVE_LLVM_TARGET_PREFIX";
/// Constructs a path to the LLVM tool `name`.
///
/// Respects the [`REVIVE_LLVM_HOST_PREFIX`] environment variable.
pub fn llvm_host_tool(name: &str) -> std::path::PathBuf {
std::env::var_os(REVIVE_LLVM_HOST_PREFIX)
.map(Into::<std::path::PathBuf>::into)
.unwrap_or_else(|| {
panic!(
"install LLVM using the revive-llvm builder and export {REVIVE_LLVM_HOST_PREFIX}",
)
})
.join("bin")
.join(name)
}
/// Returns the LLVM lib dir.
///
/// Respects the [`REVIVE_LLVM_HOST_PREFIX`] environment variable.
pub fn llvm_lib_dir() -> std::path::PathBuf {
std::path::PathBuf::from(llvm_config("--libdir").trim())
}
/// Returns the LLVM CXX compiler flags.
///
/// Respects the [`REVIVE_LLVM_HOST_PREFIX`] environment variable.
pub fn llvm_cxx_flags() -> String {
llvm_config("--cxxflags")
}
/// Execute the `llvm-config` utility respecting the [`REVIVE_LLVM_HOST_PREFIX`] environment variable.
fn llvm_config(arg: &str) -> String {
let llvm_config = llvm_host_tool("llvm-config");
let output = std::process::Command::new(&llvm_config)
.arg(arg)
.output()
.unwrap_or_else(|error| panic!("`{} {arg}` failed: {error}", llvm_config.display()));
String::from_utf8(output.stdout)
.unwrap_or_else(|_| panic!("output of `{} {arg}` should be utf8", llvm_config.display()))
}
crates/builtins/Cargo.toml
+2 -1
View File
@@ -8,4 +8,5 @@ authors.workspace = true
build = "build.rs"
description = "compiler builtins for the revive compiler"
[dependencies]
[build-dependencies]
revive-build-utils = { workspace = true }
crates/builtins/build.rs
+18 -11
View File
@@ -3,25 +3,32 @@ use std::{env, fs, io::Read, path::Path, process::Command};
pub const BUILTINS_ARCHIVE_FILE: &str = "libclang_rt.builtins-riscv64.a";
fn main() {
let mut llvm_lib_dir = String::new();
println!(
"cargo:rerun-if-env-changed={}",
revive_build_utils::REVIVE_LLVM_HOST_PREFIX
);
Command::new("llvm-config")
.args(["--libdir"])
let llvm_config = revive_build_utils::llvm_host_tool("llvm-config");
let mut llvm_lib_dir = String::new();
Command::new(&llvm_config)
.arg("--libdir")
.output()
.expect("llvm-config should be able to provide LD path")
.unwrap_or_else(|_| {
panic!(
"{} should be able to provide LD path",
llvm_config.display()
)
})
.stdout
.as_slice()
.read_to_string(&mut llvm_lib_dir)
.expect("llvm-config output should be utf8");
let mut lib_path = std::path::PathBuf::from(llvm_lib_dir.trim())
.join("linux")
let lib_path = revive_build_utils::llvm_lib_dir()
.join("unknown")
.join(BUILTINS_ARCHIVE_FILE);
if !lib_path.exists() {
lib_path = std::path::PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").unwrap())
.join(BUILTINS_ARCHIVE_FILE);
}
let archive = fs::read(lib_path).expect("clang builtins not found");
let archive = fs::read(&lib_path).expect("clang builtins not found");
println!("cargo:rerun-if-env-changed={}", lib_path.display());
let out_dir = env::var_os("OUT_DIR").expect("has OUT_DIR");
let archive_path = Path::new(&out_dir).join(BUILTINS_ARCHIVE_FILE);
crates/builtins/libclang_rt.builtins-riscv32.a
BIN
View File
Binary file not shown.
crates/builtins/libclang_rt.builtins-riscv64.a
BIN
View File
Binary file not shown.
crates/lld-sys/Cargo.toml
+1
View File
@@ -13,3 +13,4 @@ libc = { workspace = true }
[build-dependencies]
cc = { workspace = true }
revive-build-utils = { workspace = true }
crates/lld-sys/build.rs
+23 -32
View File
@@ -1,34 +1,16 @@
use std::{
env,
path::{Path, PathBuf},
};
fn set_rustc_link_flags() {
let llvm_lib_path = match std::env::var(revive_build_utils::REVIVE_LLVM_TARGET_PREFIX) {
Ok(path) => std::path::PathBuf::from(path).join("lib"),
_ => revive_build_utils::llvm_lib_dir(),
};
const LLVM_LINK_PREFIX: &str = "LLVM_LINK_PREFIX";
fn locate_llvm_config() -> PathBuf {
let prefix = env::var_os(LLVM_LINK_PREFIX)
.map(|p| PathBuf::from(p).join("bin"))
.unwrap_or_default();
prefix.join("llvm-config")
}
fn llvm_config(llvm_config_path: &Path, arg: &str) -> String {
let output = std::process::Command::new(llvm_config_path)
.args([arg])
.output()
.unwrap_or_else(|_| panic!("`llvm-config {arg}` failed"));
String::from_utf8(output.stdout)
.unwrap_or_else(|_| panic!("output of `llvm-config {arg}` should be utf8"))
}
fn set_rustc_link_flags(llvm_config_path: &Path) {
println!(
"cargo:rustc-link-search=native={}",
llvm_config(llvm_config_path, "--libdir")
llvm_lib_path.to_string_lossy()
);
for lib in [
// These are required by ld.lld
"lldELF",
"lldCommon",
"lldMachO",
@@ -91,18 +73,27 @@ fn set_rustc_link_flags(llvm_config_path: &Path) {
}
let target_os = std::env::var("CARGO_CFG_TARGET_OS").unwrap_or_default();
let target_env = std::env::var("CARGO_CFG_TARGET_ENV").unwrap_or_default();
if target_os == "linux" {
println!("cargo:rustc-link-lib=dylib=stdc++");
println!("cargo:rustc-link-lib=tinfo");
if target_env == "musl" {
println!("cargo:rustc-link-lib=static=c++");
} else {
println!("cargo:rustc-link-lib=dylib=stdc++");
}
}
}
fn main() {
println!("cargo:rerun-if-env-changed={}", LLVM_LINK_PREFIX);
println!(
"cargo:rerun-if-env-changed={}",
revive_build_utils::REVIVE_LLVM_HOST_PREFIX
);
println!(
"cargo:rerun-if-env-changed={}",
revive_build_utils::REVIVE_LLVM_TARGET_PREFIX
);
let llvm_config_path = locate_llvm_config();
llvm_config(&llvm_config_path, "--cxxflags")
revive_build_utils::llvm_cxx_flags()
.split_whitespace()
.fold(&mut cc::Build::new(), |builder, flag| builder.flag(flag))
.flag("-Wno-unused-parameter")
@@ -110,7 +101,7 @@ fn main() {
.file("src/linker.cpp")
.compile("liblinker.a");
set_rustc_link_flags(&llvm_config_path);
set_rustc_link_flags();
println!("cargo:rerun-if-changed=build.rs");
}
crates/llvm-builder/Cargo.toml
+40
View File
@@ -0,0 +1,40 @@
[package]
name = "revive-llvm-builder"
description = "revive LLVM compiler framework builder"
authors = [
"Oleksandr Zarudnyi <a.zarudnyy@matterlabs.dev>",
"Anton Baliasnikov <aba@matterlabs.dev>",
"Cyrill Leutwiler <cyrill@parity.io>",
]
version.workspace = true
license.workspace = true
edition.workspace = true
repository.workspace = true
[[bin]]
name = "revive-llvm"
path = "src/revive_llvm/main.rs"
[lib]
doctest = false
[dependencies]
clap = { workspace = true, features = ["std", "derive"] }
anyhow = { workspace = true }
serde = { workspace = true, features = [ "derive" ] }
toml = { workspace = true }
num_cpus = { workspace = true }
fs_extra = { workspace = true }
path-slash = { workspace = true }
regex = { workspace = true }
downloader = { workspace = true }
tar = { workspace = true }
flate2 = { workspace = true }
http = { workspace = true }
env_logger = { workspace = true }
log = { workspace = true }
once_cell = { workspace = true }
[dev-dependencies]
assert_cmd = { workspace = true }
assert_fs = { workspace = true }
crates/llvm-builder/README.md
+132
View File
@@ -0,0 +1,132 @@
# revive LLVM builder
Parity fork of the [Matter Labs zksync LLVM builder](https://github.com/matter-labs/era-compiler-llvm-builder) helper utility for compiling [revive](https://github.com/paritytech/revive) compatible LLVM builds.
## Installation and usage
The LLVM compiler framework for revive must be built with our tool called `revive-llvm`.
This is because the revive compiler has requirements not fullfilled in upstream builds:
- Special builds for compiling the frontend into statically linked ELF binaries and also Wasm executables
- The RISC-V target (the PolkaVM target)
- The compiler-rt builtins for the PolkaVM target
- We want to leave the assertions always on
- Various other specific configurations and optimization may be applied
Obtain a compatible build for your host platform from the release section of this repository (TODO). Alternatively follow below steps to get a custom build:
<details>
<summary>1. Install the system prerequisites.</summary>
* Linux (Debian):
Install the following packages:
```shell
apt install cmake ninja-build curl git libssl-dev pkg-config clang lld
```
* Linux (Arch):
Install the following packages:
```shell
pacman -Syu which cmake ninja curl git pkg-config clang lld
```
* MacOS:
* Install the [HomeBrew](https://brew.sh) package manager.
* Install the following packages:
```shell
brew install cmake ninja coreutils
```
* Install your choice of a recent LLVM/[Clang](https://clang.llvm.org) compiler, e.g. via [Xcode](https://developer.apple.com/xcode/), [Apple’s Command Line Tools](https://developer.apple.com/library/archive/technotes/tn2339/_index.html), or your preferred package manager.
</details>
<details>
<summary>2. Install Rust.</summary>
* Follow the latest [official instructions](https://www.rust-lang.org/tools/install:
```shell
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
. ${HOME}/.cargo/env
```
> Currently we are not pinned to any specific version of Rust, so just install the latest stable build for your platform.
</details>
<details>
<summary>3. Install the revive LLVM framework builder.</summary>
* Install the builder using `cargo`:
```shell
cargo install --git https://github.com/paritytech/revive-llvm-builder --force --locked
```
> The builder is not the LLVM framework itself, but a tool that clones its repository and runs a sequence of build commands. By default it is installed in `~/.cargo/bin/`, which is recommended to be added to your `$PATH`.
</details>
<details>
<summary>4. (Optional) Create the `LLVM.lock` file.</summary>
* The `LLVM.lock` dictates the LLVM source tree being used.
A default `./LLVM.lock` pointing to the release used for development is already provided.
</details>
<details>
<summary>5. Build LLVM.</summary>
* Clone and build the LLVM framework using the `revive-llvm` tool.
The clang and lld projects are required for the `resolc` Solidity frontend executable; they are enabled by default. LLVM assertions are also enabled by default.
```shell
revive-llvm clone
revive-llvm build
```
Build artifacts end up in the `./target-llvm/gnu/target-final/` directory by default.
The `gnu` directory depends on the supported archticture and will either be `gnu`, `musl` or `emscripten`.
You now need to export the final target directory `$LLVM_SYS_181_PREFIX`: `export LLVM_SYS_181_PREFIX=${PWD}/target-llvm/gnu/target-final`
If built with the `--enable-tests` option, test tools will be in the `./target-llvm/gnu/build-final/` directory, along with copies of the build artifacts. For all supported build options, run `revive-llvm build --help`.
</details>
## Supported target architectures
The following target platforms are supported:
- Linux GNU (x86)
- Linux MUSL (x86)
- MacOS (aarch64)
- Windows GNU (x86)
- Emscripten (wasm32)
<details>
<summary>Building for MUSL</summary>
* Via a musl build we can build revive into fully static ELF binaries.
Which is desirable for reproducible Solidity contracts builds.
The resulting binary is also very portable, akin to the`solc` frontend binary distribution.
Clone and build the LLVM framework using the `revive-llvm` tool:
```shell
revive-llvm --target-env musl clone
revive-llvm --target-env musl build --enable-assertions --llvm-projects clang --llvm-projects lld
```
</details>
<details>
<summary>Building for Emscripten</summary>
* Via an emsdk build we can run revive in the browser and on node.js.
Clone and build the LLVM framework using the `revive-llvm` tool:
```shell
revive-llvm --target-env emscripten clone
revive-llvm --target-env emscripten build --enable-assertions --llvm-projects clang --llvm-projects lld
```
</details>
crates/llvm-builder/src/build_type.rs
+39
View File
@@ -0,0 +1,39 @@
//! The revive LLVM build type.
/// The revive LLVM build type.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum BuildType {
/// The debug build.
Debug,
/// The release build.
Release,
/// The release with debug info build.
RelWithDebInfo,
/// The minimal size release build.
MinSizeRel,
}
impl std::str::FromStr for BuildType {
type Err = String;
fn from_str(value: &str) -> Result<Self, Self::Err> {
match value {
"Debug" => Ok(Self::Debug),
"Release" => Ok(Self::Release),
"RelWithDebInfo" => Ok(Self::RelWithDebInfo),
"MinSizeRel" => Ok(Self::MinSizeRel),
value => Err(format!("Unsupported build type: `{}`", value)),
}
}
}
impl std::fmt::Display for BuildType {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
Self::Debug => write!(f, "Debug"),
Self::Release => write!(f, "Release"),
Self::RelWithDebInfo => write!(f, "RelWithDebInfo"),
Self::MinSizeRel => write!(f, "MinSizeRel"),
}
}
}
crates/llvm-builder/src/builtins.rs
+137
View File
@@ -0,0 +1,137 @@
//! Utilities for compiling the LLVM compiler-rt builtins.
/// Static CFLAGS variable passed to the compiler building the compiler-rt builtins.
const C_FLAGS: [&str; 6] = [
"--target=riscv64",
"-march=rv64emac",
"-mabi=lp64e",
"-mcpu=generic-rv64",
"-nostdlib",
"-nodefaultlibs",
];
/// Static CMAKE arguments for building the compiler-rt builtins.
const CMAKE_STATIC_ARGS: [&str; 14] = [
"-DCOMPILER_RT_BUILD_BUILTINS='On'",
"-DCOMPILER_RT_BUILD_LIBFUZZER='Off'",
"-DCOMPILER_RT_BUILD_MEMPROF='Off'",
"-DCOMPILER_RT_BUILD_PROFILE='Off'",
"-DCOMPILER_RT_BUILD_SANITIZERS='Off'",
"-DCOMPILER_RT_BUILD_XRAY='Off'",
"-DCOMPILER_RT_DEFAULT_TARGET_ONLY='On'",
"-DCOMPILER_RT_BAREMETAL_BUILD='On'",
"-DCMAKE_BUILD_WITH_INSTALL_RPATH=1",
"-DCMAKE_EXPORT_COMPILE_COMMANDS='On'",
"-DCMAKE_SYSTEM_NAME='unknown'",
"-DCMAKE_C_COMPILER_TARGET='riscv64'",
"-DCMAKE_ASM_COMPILER_TARGET='riscv64'",
"-DCMAKE_CXX_COMPILER_TARGET='riscv64'",
];
/// Dynamic cmake arguments for building the compiler-rt builtins.
fn cmake_dynamic_args(
build_type: crate::BuildType,
target_env: crate::target_env::TargetEnv,
) -> anyhow::Result<[String; 13]> {
let llvm_compiler_rt_target = crate::LLVMPath::llvm_target_compiler_rt()?;
// The Emscripten target needs to use the host LLVM tools.
let llvm_target_host = if target_env == crate::target_env::TargetEnv::Emscripten {
crate::LLVMPath::llvm_build_host()?
} else {
crate::LLVMPath::llvm_target_final()?
};
let mut clang_path = llvm_target_host.to_path_buf();
clang_path.push("bin/clang");
let mut clangxx_path = llvm_target_host.to_path_buf();
clangxx_path.push("bin/clang++");
let mut llvm_config_path = llvm_target_host.to_path_buf();
llvm_config_path.push("bin/llvm-config");
let mut ar_path = llvm_target_host.to_path_buf();
ar_path.push("bin/llvm-ar");
let mut nm_path = llvm_target_host.to_path_buf();
nm_path.push("bin/llvm-nm");
let mut ranlib_path = llvm_target_host.to_path_buf();
ranlib_path.push("bin/llvm-ranlib");
let mut linker_path = llvm_target_host.to_path_buf();
linker_path.push("bin/ld.lld");
Ok([
format!(
"-DCMAKE_INSTALL_PREFIX='{}'",
llvm_compiler_rt_target.to_string_lossy().as_ref(),
),
format!("-DCMAKE_BUILD_TYPE='{build_type}'"),
format!(
"-DCOMPILER_RT_TEST_COMPILER='{}'",
clang_path.to_string_lossy()
),
format!("-DCMAKE_C_FLAGS='{}'", C_FLAGS.join(" ")),
format!("-DCMAKE_ASM_FLAGS='{}'", C_FLAGS.join(" ")),
format!("-DCMAKE_CXX_FLAGS='{}'", C_FLAGS.join(" ")),
format!("-DCMAKE_C_COMPILER='{}'", clang_path.to_string_lossy()),
format!("-DCMAKE_ASM_COMPILER='{}'", clang_path.to_string_lossy()),
format!("-DCMAKE_CXX_COMPILER='{}'", clangxx_path.to_string_lossy()),
format!("-DCMAKE_AR='{}'", ar_path.to_string_lossy()),
format!("-DCMAKE_NM='{}'", nm_path.to_string_lossy()),
format!("-DCMAKE_RANLIB='{}'", ranlib_path.to_string_lossy()),
format!(
"-DLLVM_CONFIG_PATH='{}'",
llvm_config_path.to_string_lossy()
),
])
}
/// Build the compiler-rt builtins library.
pub fn build(
build_type: crate::BuildType,
target_env: crate::target_env::TargetEnv,
default_target: Option<crate::TargetTriple>,
extra_args: &[String],
ccache_variant: Option<crate::ccache_variant::CcacheVariant>,
sanitizer: Option<crate::sanitizer::Sanitizer>,
) -> anyhow::Result<()> {
log::info!("building compiler-rt for rv64emac");
crate::utils::check_presence("cmake")?;
crate::utils::check_presence("ninja")?;
let llvm_module_compiler_rt = crate::LLVMPath::llvm_module_compiler_rt()?;
let llvm_compiler_rt_build = crate::LLVMPath::llvm_build_compiler_rt()?;
crate::utils::command(
std::process::Command::new("cmake")
.args([
"-S",
llvm_module_compiler_rt.to_string_lossy().as_ref(),
"-B",
llvm_compiler_rt_build.to_string_lossy().as_ref(),
"-G",
"Ninja",
])
.args(CMAKE_STATIC_ARGS)
.args(cmake_dynamic_args(build_type, target_env)?)
.args(extra_args)
.args(crate::platforms::shared::shared_build_opts_ccache(
ccache_variant,
))
.args(crate::platforms::shared::shared_build_opts_default_target(
default_target,
))
.args(crate::platforms::shared::shared_build_opts_sanitizers(
sanitizer,
)),
"LLVM compiler-rt building cmake",
)?;
crate::utils::ninja(&llvm_compiler_rt_build)?;
Ok(())
}
crates/llvm-builder/src/ccache_variant.rs
+31
View File
@@ -0,0 +1,31 @@
//! Compiler cache variants.
/// The list compiler cache variants to be used as constants.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum CcacheVariant {
/// Standard ccache.
Ccache,
/// Mozilla's sccache.
Sccache,
}
impl std::str::FromStr for CcacheVariant {
type Err = String;
fn from_str(value: &str) -> Result<Self, Self::Err> {
match value {
"ccache" => Ok(Self::Ccache),
"sccache" => Ok(Self::Sccache),
value => Err(format!("Unsupported ccache variant: `{}`", value)),
}
}
}
impl std::fmt::Display for CcacheVariant {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
match self {
Self::Ccache => write!(f, "ccache"),
Self::Sccache => write!(f, "sccache"),
}
}
}
crates/llvm-builder/src/lib.rs
+340
View File
@@ -0,0 +1,340 @@
//! The revive LLVM builder library.
pub mod build_type;
pub mod builtins;
pub mod ccache_variant;
pub mod llvm_path;
pub mod llvm_project;
pub mod lock;
pub mod platforms;
pub mod sanitizer;
pub mod target_env;
pub mod target_triple;
pub mod utils;
pub use self::build_type::BuildType;
pub use self::llvm_path::LLVMPath;
pub use self::lock::Lock;
pub use self::platforms::Platform;
use std::collections::HashSet;
use std::path::{Path, PathBuf};
use std::process::Command;
pub use target_env::TargetEnv;
pub use target_triple::TargetTriple;
/// Executes the LLVM repository cloning.
pub fn clone(lock: Lock, deep: bool, target_env: TargetEnv) -> anyhow::Result<()> {
utils::check_presence("git")?;
if target_env == TargetEnv::Emscripten {
utils::install_emsdk()?;
}
let destination_path = PathBuf::from(LLVMPath::DIRECTORY_LLVM_SOURCE);
if destination_path.exists() {
log::warn!(
"LLVM repository directory {} already exists, falling back to checkout",
destination_path.display()
);
return checkout(lock, false);
}
let mut clone_args = vec!["clone", "--branch", lock.branch.as_str()];
if !deep {
clone_args.push("--depth");
clone_args.push("1");
}
utils::command(
Command::new("git")
.args(clone_args)
.arg(lock.url.as_str())
.arg(destination_path.to_string_lossy().as_ref()),
"LLVM repository cloning",
)?;
if let Some(r#ref) = lock.r#ref {
utils::command(
Command::new("git")
.args(["checkout", r#ref.as_str()])
.current_dir(destination_path.to_string_lossy().as_ref()),
"LLVM repository commit checking out",
)?;
}
Ok(())
}
/// Executes the checkout of the specified branch.
pub fn checkout(lock: Lock, force: bool) -> anyhow::Result<()> {
let destination_path = PathBuf::from(LLVMPath::DIRECTORY_LLVM_SOURCE);
utils::command(
Command::new("git")
.current_dir(destination_path.as_path())
.args(["fetch", "--all", "--tags"]),
"LLVM repository data fetching",
)?;
if force {
utils::command(
Command::new("git")
.current_dir(destination_path.as_path())
.args(["clean", "-d", "-x", "--force"]),
"LLVM repository cleaning",
)?;
}
utils::command(
Command::new("git")
.current_dir(destination_path.as_path())
.args(["checkout", "--force", lock.branch.as_str()]),
"LLVM repository data pulling",
)?;
if let Some(r#ref) = lock.r#ref {
let mut checkout_command = Command::new("git");
checkout_command.current_dir(destination_path.as_path());
checkout_command.arg("checkout");
if force {
checkout_command.arg("--force");
}
checkout_command.arg(r#ref);
utils::command(&mut checkout_command, "LLVM repository checking out")?;
}
Ok(())
}
/// Executes the building of the LLVM framework for the platform determined by the cfg macro.
/// Since cfg is evaluated at compile time, overriding the platform with a command-line
/// argument is not possible. So for cross-platform testing, comment out all but the
/// line to be tested, and perhaps also checks in the platform-specific build method.
#[allow(clippy::too_many_arguments)]
pub fn build(
build_type: BuildType,
target_env: TargetEnv,
targets: HashSet<Platform>,
llvm_projects: HashSet<llvm_project::LLVMProject>,
enable_rtti: bool,
default_target: Option<TargetTriple>,
enable_tests: bool,
enable_coverage: bool,
extra_args: &[String],
ccache_variant: Option<ccache_variant::CcacheVariant>,
enable_assertions: bool,
sanitizer: Option<sanitizer::Sanitizer>,
enable_valgrind: bool,
) -> anyhow::Result<()> {
log::trace!("build type: {:?}", build_type);
log::trace!("target env: {:?}", target_env);
log::trace!("targets: {:?}", targets);
log::trace!("llvm projects: {:?}", llvm_projects);
log::trace!("enable rtti: {:?}", enable_rtti);
log::trace!("default target: {:?}", default_target);
log::trace!("eneable tests: {:?}", enable_tests);
log::trace!("enable_coverage: {:?}", enable_coverage);
log::trace!("extra args: {:?}", extra_args);
log::trace!("sanitzer: {:?}", sanitizer);
log::trace!("enable valgrind: {:?}", enable_valgrind);
if !PathBuf::from(LLVMPath::DIRECTORY_LLVM_SOURCE).exists() {
log::error!(
"LLVM project source directory {} does not exist (run `revive-llvm --target-env {} clone`)",
LLVMPath::DIRECTORY_LLVM_SOURCE,
target_env
)
}
std::fs::create_dir_all(llvm_path::DIRECTORY_LLVM_TARGET.get().unwrap())?;
if cfg!(target_arch = "x86_64") {
if cfg!(target_os = "linux") {
if target_env == TargetEnv::MUSL {
platforms::x86_64_linux_musl::build(
build_type,
targets,
llvm_projects,
enable_rtti,
default_target,
enable_tests,
enable_coverage,
extra_args,
ccache_variant,
enable_assertions,
sanitizer,
enable_valgrind,
)?;
} else if target_env == TargetEnv::GNU {
platforms::x86_64_linux_gnu::build(
build_type,
targets,
llvm_projects,
enable_rtti,
default_target,
enable_tests,
enable_coverage,
extra_args,
ccache_variant,
enable_assertions,
sanitizer,
enable_valgrind,
)?;
} else if target_env == TargetEnv::Emscripten {
platforms::wasm32_emscripten::build(
build_type,
targets,
llvm_projects,
enable_rtti,
default_target,
enable_tests,
enable_coverage,
extra_args,
ccache_variant,
enable_assertions,
sanitizer,
enable_valgrind,
)?;
} else {
anyhow::bail!("Unsupported target environment for x86_64 and Linux");
}
} else if cfg!(target_os = "macos") {
platforms::x86_64_macos::build(
build_type,
targets,
llvm_projects,
enable_rtti,
default_target,
enable_tests,
enable_coverage,
extra_args,
ccache_variant,
enable_assertions,
sanitizer,
)?;
} else if cfg!(target_os = "windows") {
platforms::x86_64_windows_gnu::build(
build_type,
targets,
llvm_projects,
enable_rtti,
default_target,
enable_tests,
enable_coverage,
extra_args,
ccache_variant,
enable_assertions,
sanitizer,
)?;
} else {
anyhow::bail!("Unsupported target OS for x86_64");
}
} else if cfg!(target_arch = "aarch64") {
if cfg!(target_os = "linux") {
if target_env == TargetEnv::MUSL {
platforms::aarch64_linux_musl::build(
build_type,
targets,
llvm_projects,
enable_rtti,
default_target,
enable_tests,
enable_coverage,
extra_args,
ccache_variant,
enable_assertions,
sanitizer,
enable_valgrind,
)?;
} else if target_env == TargetEnv::GNU {
platforms::aarch64_linux_gnu::build(
build_type,
targets,
llvm_projects,
enable_rtti,
default_target,
enable_tests,
enable_coverage,
extra_args,
ccache_variant,
enable_assertions,
sanitizer,
enable_valgrind,
)?;
} else {
anyhow::bail!("Unsupported target environment for aarch64 and Linux");
}
} else if cfg!(target_os = "macos") {
if target_env == TargetEnv::Emscripten {
platforms::wasm32_emscripten::build(
build_type,
targets,
llvm_projects,
enable_rtti,
default_target,
enable_tests,
enable_coverage,
extra_args,
ccache_variant,
enable_assertions,
sanitizer,
enable_valgrind,
)?;
} else {
platforms::aarch64_macos::build(
build_type,
targets,
llvm_projects,
enable_rtti,
default_target,
enable_tests,
enable_coverage,
extra_args,
ccache_variant,
enable_assertions,
sanitizer,
)?;
}
} else {
anyhow::bail!("Unsupported target OS for aarch64");
}
} else {
anyhow::bail!("Unsupported target architecture");
}
crate::builtins::build(
build_type,
target_env,
default_target,
extra_args,
ccache_variant,
sanitizer,
)?;
Ok(())
}
/// Executes the build artifacts cleaning.
pub fn clean() -> anyhow::Result<()> {
let remove_if_exists = |path: &Path| {
if !path.exists() {
return Ok(());
}
log::info!("deleting {}", path.display());
std::fs::remove_dir_all(path)
};
remove_if_exists(
llvm_path::DIRECTORY_LLVM_TARGET
.get()
.expect("target_env is always set because of the default value")
.parent()
.expect("target_env parent directory is target-llvm"),
)?;
remove_if_exists(&PathBuf::from(LLVMPath::DIRECTORY_EMSDK_SOURCE))?;
remove_if_exists(&PathBuf::from(LLVMPath::DIRECTORY_LLVM_SOURCE))?;
remove_if_exists(&PathBuf::from(LLVMPath::DIRECTORY_LLVM_HOST_SOURCE))?;
Ok(())
}
crates/llvm-builder/src/llvm_path.rs
+151
View File
@@ -0,0 +1,151 @@
//! The revive LLVM builder constants.
use std::path::PathBuf;
use std::sync::OnceLock;
pub static DIRECTORY_LLVM_TARGET: OnceLock<PathBuf> = OnceLock::new();
/// The LLVM path resolver.
pub struct LLVMPath {}
impl LLVMPath {
/// The LLVM source directory.
pub const DIRECTORY_LLVM_SOURCE: &'static str = "./llvm/";
/// The LLVM host source directory for stage 1 of multistage MUSL and Emscripten builds.
///
/// We use upstream LLVM anyways; re-use the same tree for host and target builds.
pub const DIRECTORY_LLVM_HOST_SOURCE: &'static str = Self::DIRECTORY_LLVM_SOURCE;
/// The Emscripten SDK source directory.
pub const DIRECTORY_EMSDK_SOURCE: &'static str = "./emsdk/";
/// Returns the path to the `llvm` stage 1 host LLVM source module directory.
pub fn llvm_host_module_llvm() -> anyhow::Result<PathBuf> {
let mut path = PathBuf::from(Self::DIRECTORY_LLVM_HOST_SOURCE);
path.push("llvm");
crate::utils::absolute_path(path).inspect(|absolute_path| {
log::debug!(
"llvm stage 1 host llvm source module: {}",
absolute_path.display()
)
})
}
/// Returns the path to the `llvm` LLVM source module directory.
pub fn llvm_module_llvm() -> anyhow::Result<PathBuf> {
let mut path = PathBuf::from(Self::DIRECTORY_LLVM_SOURCE);
path.push("llvm");
crate::utils::absolute_path(path)
.inspect(|absolute_path| log::debug!("llvm source module: {}", absolute_path.display()))
}
/// Returns the path to the MUSL source.
pub fn musl_source(name: &str) -> anyhow::Result<PathBuf> {
let mut path = PathBuf::from(DIRECTORY_LLVM_TARGET.get().unwrap());
path.push(name);
crate::utils::absolute_path(path)
.inspect(|absolute_path| log::debug!("musl source: {}", absolute_path.display()))
}
/// Returns the path to the MUSL build directory.
pub fn musl_build(source_directory: &str) -> anyhow::Result<PathBuf> {
let mut path = PathBuf::from(DIRECTORY_LLVM_TARGET.get().unwrap());
path.push(source_directory);
path.push("build");
crate::utils::absolute_path(path)
.inspect(|absolute_path| log::debug!("musl build: '{}'", absolute_path.display()))
}
/// Returns the path to the LLVM CRT build directory.
pub fn llvm_build_crt() -> anyhow::Result<PathBuf> {
let mut path = PathBuf::from(DIRECTORY_LLVM_TARGET.get().unwrap());
path.push("build-crt");
crate::utils::absolute_path(path)
.inspect(|absolute_path| log::debug!("llvm build crt: {}", absolute_path.display()))
}
/// Returns the path to the LLVM host build directory.
pub fn llvm_build_host() -> anyhow::Result<PathBuf> {
let mut path = PathBuf::from(DIRECTORY_LLVM_TARGET.get().unwrap());
path.push("build-host");
crate::utils::absolute_path(path)
.inspect(|absolute_path| log::debug!("llvm build host: {}", absolute_path.display()))
}
/// Returns the path to the LLVM final build directory.
pub fn llvm_build_final() -> anyhow::Result<PathBuf> {
let mut path = PathBuf::from(DIRECTORY_LLVM_TARGET.get().unwrap());
path.push("build-final");
crate::utils::absolute_path(path)
.inspect(|absolute_path| log::debug!("llvm build final: {}", absolute_path.display()))
}
/// Returns the path to the MUSL target directory.
pub fn musl_target() -> anyhow::Result<PathBuf> {
let mut path = PathBuf::from(DIRECTORY_LLVM_TARGET.get().unwrap());
path.push("target-musl");
crate::utils::absolute_path(path)
.inspect(|absolute_path| log::debug!("musl target: {}", absolute_path.display()))
}
/// Returns the path to the LLVM CRT target directory.
pub fn llvm_target_crt() -> anyhow::Result<PathBuf> {
let mut path = PathBuf::from(DIRECTORY_LLVM_TARGET.get().unwrap());
path.push("target-crt");
crate::utils::absolute_path(path)
.inspect(|absolute_path| log::debug!("llvm crt target: {}", absolute_path.display()))
}
/// Returns the path to the LLVM host target directory.
pub fn llvm_target_host() -> anyhow::Result<PathBuf> {
let mut path = PathBuf::from(DIRECTORY_LLVM_TARGET.get().unwrap());
path.push("target-host");
crate::utils::absolute_path(path)
.inspect(|absolute_path| log::debug!("llvm host target: {}", absolute_path.display()))
}
/// Returns the path to the LLVM final target directory.
pub fn llvm_target_final() -> anyhow::Result<PathBuf> {
let mut path = PathBuf::from(DIRECTORY_LLVM_TARGET.get().unwrap());
path.push("target-final");
crate::utils::absolute_path(path)
.inspect(|absolute_path| log::debug!("llvm final target: {}", absolute_path.display()))
}
/// Returns the path to the LLVM compiler builtin target directory.
pub fn llvm_module_compiler_rt() -> anyhow::Result<PathBuf> {
let mut path = PathBuf::from(Self::DIRECTORY_LLVM_SOURCE);
path.push("compiler-rt");
crate::utils::absolute_path(path).inspect(|absolute_path| {
log::debug!("compiler-rt source dir: {}", absolute_path.display())
})
}
/// Returns the path to the LLVM compiler-rt target directory.
pub fn llvm_target_compiler_rt() -> anyhow::Result<PathBuf> {
Self::llvm_target_final()
}
/// Returns the path to the LLVM compiler-rt build directory.
pub fn llvm_build_compiler_rt() -> anyhow::Result<PathBuf> {
let mut path = PathBuf::from(DIRECTORY_LLVM_TARGET.get().unwrap());
path.push("build-compiler-rt");
crate::utils::absolute_path(path).inspect(|absolute_path| {
log::debug!("llvm compiler-rt build: {}", absolute_path.display())
})
}
/// Returns the path to the LLVM target final bin path.
///
pub fn llvm_target_final_bin(
target_env: crate::target_env::TargetEnv,
) -> anyhow::Result<PathBuf> {
let mut path = Self::llvm_target_final()?;
path.push("bin");
path.push(format!("{target_env}"));
crate::utils::absolute_path(path).inspect(|absolute_path| {
log::debug!("llvm target final bin: {}", absolute_path.display())
})
}
}
crates/llvm-builder/src/llvm_project.rs
+39
View File
@@ -0,0 +1,39 @@
//! The LLVM projects to enable during the build.
/// The list of LLVM projects used as constants.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum LLVMProject {
/// The Clang compiler.
CLANG,
/// LLD, the LLVM linker.
LLD,
/// The LLVM debugger.
LLDB,
/// The MLIR compiler.
MLIR,
}
impl std::str::FromStr for LLVMProject {
type Err = String;
fn from_str(value: &str) -> Result<Self, Self::Err> {
match value.to_lowercase().as_str() {
"clang" => Ok(Self::CLANG),
"lld" => Ok(Self::LLD),
"lldb" => Ok(Self::LLDB),
"mlir" => Ok(Self::MLIR),
value => Err(format!("Unsupported LLVM project to enable: `{}`", value)),
}
}
}
impl std::fmt::Display for LLVMProject {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
match self {
Self::CLANG => write!(f, "clang"),
Self::LLD => write!(f, "lld"),
Self::LLDB => write!(f, "lldb"),
Self::MLIR => write!(f, "mlir"),
}
}
}
crates/llvm-builder/src/lock.rs
+37
View File
@@ -0,0 +1,37 @@
//! The revive LLVM builder lock file.
use anyhow::Context;
use std::fs::File;
use std::io::Read;
use std::path::PathBuf;
use serde::Deserialize;
use serde::Serialize;
/// The default lock file location.
pub const LLVM_LOCK_DEFAULT_PATH: &str = "LLVM.lock";
/// The lock file data.
///
/// This file describes the exact reference of the LLVM framework.
#[derive(Debug, Deserialize, Serialize)]
pub struct Lock {
/// The LLVM repository URL.
pub url: String,
/// The LLVM repository branch.
pub branch: String,
/// The LLVM repository commit reference.
pub r#ref: Option<String>,
}
impl TryFrom<&PathBuf> for Lock {
type Error = anyhow::Error;
fn try_from(path: &PathBuf) -> Result<Self, Self::Error> {
let mut config_str = String::new();
let mut config_file =
File::open(path).with_context(|| format!("Error opening {:?} file", path))?;
config_file.read_to_string(&mut config_str)?;
Ok(toml::from_str(&config_str)?)
}
}
crates/llvm-builder/src/platforms/aarch64_linux_gnu.rs
+111
View File
@@ -0,0 +1,111 @@
//! The revive LLVM arm64 `linux-gnu` builder.
use std::collections::HashSet;
use std::process::Command;
use crate::build_type::BuildType;
use crate::ccache_variant::CcacheVariant;
use crate::llvm_path::LLVMPath;
use crate::llvm_project::LLVMProject;
use crate::platforms::Platform;
use crate::sanitizer::Sanitizer;
use crate::target_triple::TargetTriple;
/// The building sequence.
#[allow(clippy::too_many_arguments)]
pub fn build(
build_type: BuildType,
targets: HashSet<Platform>,
llvm_projects: HashSet<LLVMProject>,
enable_rtti: bool,
default_target: Option<TargetTriple>,
enable_tests: bool,
enable_coverage: bool,
extra_args: &[String],
ccache_variant: Option<CcacheVariant>,
enable_assertions: bool,
sanitizer: Option<Sanitizer>,
enable_valgrind: bool,
) -> anyhow::Result<()> {
crate::utils::check_presence("cmake")?;
crate::utils::check_presence("clang")?;
crate::utils::check_presence("clang++")?;
crate::utils::check_presence("lld")?;
crate::utils::check_presence("ninja")?;
let llvm_module_llvm = LLVMPath::llvm_module_llvm()?;
let llvm_build_final = LLVMPath::llvm_build_final()?;
let llvm_target_final = LLVMPath::llvm_target_final()?;
crate::utils::command(
Command::new("cmake")
.args([
"-S",
llvm_module_llvm.to_string_lossy().as_ref(),
"-B",
llvm_build_final.to_string_lossy().as_ref(),
"-G",
"Ninja",
format!(
"-DCMAKE_INSTALL_PREFIX='{}'",
llvm_target_final.to_string_lossy().as_ref(),
)
.as_str(),
format!("-DCMAKE_BUILD_TYPE='{build_type}'").as_str(),
"-DCMAKE_C_COMPILER='clang'",
"-DCMAKE_CXX_COMPILER='clang++'",
format!(
"-DLLVM_TARGETS_TO_BUILD='{}'",
targets
.into_iter()
.map(|platform| platform.to_string())
.collect::<Vec<String>>()
.join(";")
)
.as_str(),
format!(
"-DLLVM_ENABLE_PROJECTS='{}'",
llvm_projects
.into_iter()
.map(|project| project.to_string())
.collect::<Vec<String>>()
.join(";")
)
.as_str(),
"-DLLVM_USE_LINKER='lld'",
])
.args(crate::platforms::shared::shared_build_opts_default_target(
default_target,
))
.args(crate::platforms::shared::shared_build_opts_tests(
enable_tests,
))
.args(crate::platforms::shared::shared_build_opts_coverage(
enable_coverage,
))
.args(crate::platforms::shared::SHARED_BUILD_OPTS)
.args(crate::platforms::shared::SHARED_BUILD_OPTS_NOT_MUSL)
.args(crate::platforms::shared::shared_build_opts_werror(
crate::target_env::TargetEnv::GNU,
))
.args(extra_args)
.args(crate::platforms::shared::shared_build_opts_ccache(
ccache_variant,
))
.args(crate::platforms::shared::shared_build_opts_assertions(
enable_assertions,
))
.args(crate::platforms::shared::shared_build_opts_rtti(
enable_rtti,
))
.args(crate::platforms::shared::shared_build_opts_sanitizers(
sanitizer,
))
.args(crate::platforms::shared::shared_build_opts_valgrind(
enable_valgrind,
)),
"LLVM building cmake",
)?;
crate::utils::ninja(llvm_build_final.as_ref())?;
Ok(())
}
crates/llvm-builder/src/platforms/aarch64_linux_musl.rs
+394
View File
@@ -0,0 +1,394 @@
//! The revive LLVM arm64 `linux-musl` builder.
use crate::build_type::BuildType;
use crate::ccache_variant::CcacheVariant;
use crate::llvm_path::LLVMPath;
use crate::llvm_project::LLVMProject;
use crate::platforms::Platform;
use crate::sanitizer::Sanitizer;
use crate::target_triple::TargetTriple;
use std::collections::HashSet;
use std::path::Path;
use std::process::Command;
/// The building sequence.
#[allow(clippy::too_many_arguments)]
pub fn build(
build_type: BuildType,
targets: HashSet<Platform>,
llvm_projects: HashSet<LLVMProject>,
enable_rtti: bool,
default_target: Option<TargetTriple>,
enable_tests: bool,
enable_coverage: bool,
extra_args: &[String],
ccache_variant: Option<CcacheVariant>,
enable_assertions: bool,
sanitizer: Option<Sanitizer>,
enable_valgrind: bool,
) -> anyhow::Result<()> {
crate::utils::check_presence("cmake")?;
crate::utils::check_presence("clang")?;
crate::utils::check_presence("clang++")?;
crate::utils::check_presence("lld")?;
crate::utils::check_presence("ninja")?;
let musl_name = "musl-1.2.3";
let musl_build = LLVMPath::musl_build(musl_name)?;
let musl_target = LLVMPath::musl_target()?;
let llvm_module_llvm = LLVMPath::llvm_module_llvm()?;
let llvm_host_module_llvm = LLVMPath::llvm_host_module_llvm()?;
let llvm_build_crt = LLVMPath::llvm_build_crt()?;
let llvm_target_crt = LLVMPath::llvm_target_crt()?;
let llvm_build_host = LLVMPath::llvm_build_host()?;
let llvm_target_host = LLVMPath::llvm_target_host()?;
let llvm_build_final = LLVMPath::llvm_build_final()?;
let llvm_target_final = LLVMPath::llvm_target_final()?;
if !LLVMPath::musl_source(musl_name)?.exists() {
crate::utils::download_musl(musl_name)?;
}
crate::platforms::shared::build_musl(musl_build.as_path(), musl_target.as_path())?;
build_crt(
targets.clone(),
llvm_host_module_llvm.as_path(),
llvm_build_crt.as_path(),
llvm_target_crt.as_path(),
ccache_variant,
)?;
build_host(
llvm_host_module_llvm.as_path(),
llvm_build_host.as_path(),
llvm_target_host.as_path(),
musl_target.as_path(),
llvm_target_crt.as_path(),
ccache_variant,
)?;
build_target(
build_type,
targets,
llvm_projects,
enable_rtti,
default_target,
llvm_module_llvm.as_path(),
llvm_build_final.as_path(),
llvm_target_final.as_path(),
musl_target.as_path(),
llvm_target_host.as_path(),
enable_tests,
enable_coverage,
extra_args,
ccache_variant,
enable_assertions,
sanitizer,
enable_valgrind,
)?;
Ok(())
}
///
/// The `crt` building sequence.
///
fn build_crt(
mut targets: HashSet<Platform>,
source_directory: &Path,
build_directory: &Path,
target_directory: &Path,
ccache_variant: Option<CcacheVariant>,
) -> anyhow::Result<()> {
targets.insert(Platform::AArch64);
crate::utils::command(
Command::new("cmake")
.args([
"-S",
source_directory.to_string_lossy().as_ref(),
"-B",
build_directory.to_string_lossy().as_ref(),
"-G",
"Ninja",
format!(
"-DCMAKE_INSTALL_PREFIX='{}'",
target_directory.to_string_lossy()
)
.as_str(),
"-DCMAKE_BUILD_TYPE='Release'",
"-DCMAKE_C_COMPILER='clang'",
"-DCMAKE_CXX_COMPILER='clang++'",
"-DLLVM_ENABLE_PROJECTS='compiler-rt'",
format!("-DLLVM_TARGETS_TO_BUILD='{}'", Platform::AArch64).as_str(),
"-DLLVM_DEFAULT_TARGET_TRIPLE='aarch64-unknown-linux-musl'",
"-DLLVM_BUILD_TESTS='Off'",
"-DLLVM_BUILD_RUNTIMES='Off'",
"-DLLVM_BUILD_UTILS='Off'",
"-DLLVM_INCLUDE_TESTS='Off'",
"-DLLVM_INCLUDE_RUNTIMES='Off'",
"-DLLVM_INCLUDE_UTILS='Off'",
"-DCOMPILER_RT_DEFAULT_TARGET_ARCH='aarch64'",
"-DCOMPILER_RT_BUILD_CRT='On'",
"-DCOMPILER_RT_BUILD_BUILTINS='On'",
"-DCOMPILER_RT_BUILD_SANITIZERS='Off'",
"-DCOMPILER_RT_BUILD_XRAY='Off'",
"-DCOMPILER_RT_BUILD_LIBFUZZER='Off'",
"-DCOMPILER_RT_BUILD_PROFILE='Off'",
"-DCOMPILER_RT_BUILD_MEMPROF='Off'",
"-DCOMPILER_RT_BUILD_ORC='Off'",
])
.args(crate::platforms::shared::SHARED_BUILD_OPTS)
.args(crate::platforms::shared::shared_build_opts_ccache(
ccache_variant,
)),
"CRT building cmake",
)?;
crate::utils::command(
Command::new("ninja")
.arg("-C")
.arg(build_directory)
.arg("install-crt"),
"CRT building ninja",
)?;
Ok(())
}
///
/// The host toolchain building sequence.
///
fn build_host(
source_directory: &Path,
build_directory: &Path,
target_directory: &Path,
musl_target_directory: &Path,
crt_target_directory: &Path,
ccache_variant: Option<CcacheVariant>,
) -> anyhow::Result<()> {
crate::utils::command(
Command::new("cmake")
.args([
"-S",
source_directory.to_string_lossy().as_ref(),
"-B",
build_directory.to_string_lossy().as_ref(),
"-G",
"Ninja",
format!(
"-DDEFAULT_SYSROOT='{}'",
musl_target_directory.to_string_lossy()
)
.as_str(),
"-DLINKER_SUPPORTS_COLOR_DIAGNOSTICS=0",
format!(
"-DCMAKE_INSTALL_PREFIX='{}'",
target_directory.to_string_lossy()
)
.as_str(),
"-DCMAKE_BUILD_TYPE='Release'",
"-DCMAKE_C_COMPILER='clang'",
"-DCMAKE_CXX_COMPILER='clang++'",
"-DCLANG_DEFAULT_CXX_STDLIB='libc++'",
"-DCLANG_DEFAULT_RTLIB='compiler-rt'",
"-DLLVM_DEFAULT_TARGET_TRIPLE='aarch64-unknown-linux-musl'",
"-DLLVM_TARGETS_TO_BUILD='AArch64'",
"-DLLVM_BUILD_TESTS='Off'",
"-DLLVM_BUILD_UTILS='Off'",
"-DLLVM_INCLUDE_TESTS='Off'",
"-DLLVM_INCLUDE_UTILS='Off'",
"-DLLVM_ENABLE_PROJECTS='clang;lld'",
"-DLLVM_ENABLE_RUNTIMES='compiler-rt;libcxx;libcxxabi;libunwind'",
"-DLIBCXX_CXX_ABI='libcxxabi'",
"-DLIBCXX_HAS_MUSL_LIBC='On'",
"-DLIBCXX_ENABLE_SHARED='Off'",
"-DLIBCXX_ENABLE_STATIC='On'",
"-DLIBCXX_ENABLE_STATIC_ABI_LIBRARY='On'",
"-DLIBCXXABI_ENABLE_SHARED='Off'",
"-DLIBCXXABI_ENABLE_STATIC='On'",
"-DLIBCXXABI_ENABLE_STATIC_UNWINDER='On'",
"-DLIBCXXABI_USE_LLVM_UNWINDER='On'",
"-DLIBCXXABI_USE_COMPILER_RT='On'",
"-DLIBUNWIND_ENABLE_STATIC='On'",
"-DLIBUNWIND_ENABLE_SHARED='Off'",
"-DCOMPILER_RT_BUILD_CRT='On'",
"-DCOMPILER_RT_BUILD_SANITIZERS='Off'",
"-DCOMPILER_RT_BUILD_XRAY='Off'",
"-DCOMPILER_RT_BUILD_LIBFUZZER='Off'",
"-DCOMPILER_RT_BUILD_PROFILE='On'",
"-DCOMPILER_RT_BUILD_MEMPROF='Off'",
"-DCOMPILER_RT_BUILD_ORC='Off'",
"-DCOMPILER_RT_DEFAULT_TARGET_ARCH='aarch64'",
"-DCOMPILER_RT_DEFAULT_TARGET_ONLY='On'",
])
.args(crate::platforms::shared::SHARED_BUILD_OPTS)
.args(crate::platforms::shared::shared_build_opts_ccache(
ccache_variant,
)),
"LLVM host building cmake",
)?;
let mut crt_lib_directory = crt_target_directory.to_path_buf();
crt_lib_directory.push("lib/");
let mut build_lib_directory = build_directory.to_path_buf();
build_lib_directory.push("lib/");
let copy_options = fs_extra::dir::CopyOptions {
overwrite: true,
copy_inside: true,
content_only: true,
..Default::default()
};
fs_extra::dir::copy(crt_lib_directory, build_lib_directory, &copy_options)?;
crate::utils::command(
Command::new("ninja")
.arg("-C")
.arg(build_directory)
.arg("install"),
"LLVM host building ninja",
)?;
Ok(())
}
///
/// The target toolchain building sequence.
///
#[allow(clippy::too_many_arguments)]
fn build_target(
build_type: BuildType,
targets: HashSet<Platform>,
llvm_projects: HashSet<LLVMProject>,
enable_rtti: bool,
default_target: Option<TargetTriple>,
source_directory: &Path,
build_directory: &Path,
target_directory: &Path,
musl_target_directory: &Path,
host_target_directory: &Path,
enable_tests: bool,
enable_coverage: bool,
extra_args: &[String],
ccache_variant: Option<CcacheVariant>,
enable_assertions: bool,
sanitizer: Option<Sanitizer>,
enable_valgrind: bool,
) -> anyhow::Result<()> {
let mut clang_path = host_target_directory.to_path_buf();
clang_path.push("bin/clang");
let mut clang_cxx_path = host_target_directory.to_path_buf();
clang_cxx_path.push("bin/clang++");
crate::utils::command(
Command::new("cmake")
.args([
"-S",
source_directory.to_string_lossy().as_ref(),
"-B",
build_directory.to_string_lossy().as_ref(),
"-G",
"Ninja",
"-DBUILD_SHARED_LIBS='Off'",
"-DLINKER_SUPPORTS_COLOR_DIAGNOSTICS=0",
format!(
"-DCMAKE_INSTALL_PREFIX='{}'",
target_directory.to_string_lossy()
)
.as_str(),
format!("-DCMAKE_BUILD_TYPE='{build_type}'").as_str(),
format!("-DCMAKE_C_COMPILER='{}'", clang_path.to_string_lossy()).as_str(),
format!(
"-DCMAKE_CXX_COMPILER='{}'",
clang_cxx_path.to_string_lossy()
)
.as_str(),
"-DCMAKE_FIND_LIBRARY_SUFFIXES='.a'",
"-DCMAKE_BUILD_WITH_INSTALL_RPATH=1",
"-DCMAKE_EXE_LINKER_FLAGS='-fuse-ld=lld -static'",
format!(
"-DLLVM_TARGETS_TO_BUILD='{}'",
targets
.into_iter()
.map(|platform| platform.to_string())
.collect::<Vec<String>>()
.join(";")
)
.as_str(),
format!(
"-DLLVM_ENABLE_PROJECTS='{}'",
llvm_projects
.into_iter()
.map(|project| project.to_string())
.collect::<Vec<String>>()
.join(";")
)
.as_str(),
])
.args(crate::platforms::shared::shared_build_opts_default_target(
default_target,
))
.args(crate::platforms::shared::SHARED_BUILD_OPTS)
.args(crate::platforms::shared::SHARED_BUILD_OPTS_NOT_MUSL)
.args(crate::platforms::shared::shared_build_opts_werror(
crate::target_env::TargetEnv::MUSL,
))
.args(crate::platforms::shared::shared_build_opts_tests(
enable_tests,
))
.args(crate::platforms::shared::shared_build_opts_coverage(
enable_coverage,
))
.args(extra_args)
.args(crate::platforms::shared::shared_build_opts_ccache(
ccache_variant,
))
.args(crate::platforms::shared::shared_build_opts_assertions(
enable_assertions,
))
.args(crate::platforms::shared::shared_build_opts_rtti(
enable_rtti,
))
.args(crate::platforms::shared::shared_build_opts_sanitizers(
sanitizer,
))
.args(crate::platforms::shared::shared_build_opts_valgrind(
enable_valgrind,
)),
"LLVM target building cmake",
)?;
crate::utils::ninja(build_directory)?;
let mut musl_lib_directory = musl_target_directory.to_path_buf();
musl_lib_directory.push("lib/");
let mut host_lib_directory = host_target_directory.to_path_buf();
host_lib_directory.push("lib/aarch64-unknown-linux-musl/");
let mut target_lib_directory = target_directory.to_path_buf();
target_lib_directory.push("lib/");
let copy_options = fs_extra::dir::CopyOptions {
overwrite: true,
copy_inside: true,
content_only: true,
..Default::default()
};
fs_extra::dir::copy(
musl_lib_directory,
target_lib_directory.as_path(),
&copy_options,
)?;
fs_extra::dir::copy(
host_lib_directory,
target_lib_directory.as_path(),
&copy_options,
)?;
Ok(())
}
crates/llvm-builder/src/platforms/aarch64_macos.rs
+105
View File
@@ -0,0 +1,105 @@
//! The revive LLVM arm64 `macos-aarch64` builder.
use std::collections::HashSet;
use std::process::Command;
use crate::build_type::BuildType;
use crate::ccache_variant::CcacheVariant;
use crate::llvm_path::LLVMPath;
use crate::llvm_project::LLVMProject;
use crate::platforms::Platform;
use crate::sanitizer::Sanitizer;
use crate::target_triple::TargetTriple;
/// The building sequence.
#[allow(clippy::too_many_arguments)]
pub fn build(
build_type: BuildType,
targets: HashSet<Platform>,
llvm_projects: HashSet<LLVMProject>,
enable_rtti: bool,
default_target: Option<TargetTriple>,
enable_tests: bool,
enable_coverage: bool,
extra_args: &[String],
ccache_variant: Option<CcacheVariant>,
enable_assertions: bool,
sanitizer: Option<Sanitizer>,
) -> anyhow::Result<()> {
crate::utils::check_presence("cmake")?;
crate::utils::check_presence("ninja")?;
let llvm_module_llvm = LLVMPath::llvm_module_llvm()?;
let llvm_build_final = LLVMPath::llvm_build_final()?;
let llvm_target_final = LLVMPath::llvm_target_final()?;
crate::utils::command(
Command::new("cmake")
.args([
"-S",
llvm_module_llvm.to_string_lossy().as_ref(),
"-B",
llvm_build_final.to_string_lossy().as_ref(),
"-G",
"Ninja",
format!(
"-DCMAKE_INSTALL_PREFIX='{}'",
llvm_target_final.to_string_lossy().as_ref(),
)
.as_str(),
format!("-DCMAKE_BUILD_TYPE='{build_type}'").as_str(),
format!(
"-DLLVM_TARGETS_TO_BUILD='{}'",
targets
.into_iter()
.map(|platform| platform.to_string())
.collect::<Vec<String>>()
.join(";")
)
.as_str(),
format!(
"-DLLVM_ENABLE_PROJECTS='{}'",
llvm_projects
.into_iter()
.map(|project| project.to_string())
.collect::<Vec<String>>()
.join(";")
)
.as_str(),
"-DCMAKE_OSX_DEPLOYMENT_TARGET='11.0'",
])
.args(crate::platforms::shared::shared_build_opts_default_target(
default_target,
))
.args(crate::platforms::shared::shared_build_opts_tests(
enable_tests,
))
.args(crate::platforms::shared::shared_build_opts_coverage(
enable_coverage,
))
.args(crate::platforms::shared::SHARED_BUILD_OPTS)
.args(crate::platforms::shared::SHARED_BUILD_OPTS_NOT_MUSL)
.args(crate::platforms::shared::shared_build_opts_werror(
crate::target_env::TargetEnv::GNU,
))
.args(extra_args)
.args(crate::platforms::shared::shared_build_opts_ccache(
ccache_variant,
))
.args(crate::platforms::shared::shared_build_opts_assertions(
enable_assertions,
))
.args(crate::platforms::shared::shared_build_opts_rtti(
enable_rtti,
))
.args(crate::platforms::shared::macos_build_opts_ignore_dupicate_libs_warnings())
.args(crate::platforms::shared::shared_build_opts_sanitizers(
sanitizer,
)),
"LLVM building cmake",
)?;
crate::utils::ninja(llvm_build_final.as_ref())?;
Ok(())
}
crates/llvm-builder/src/platforms/mod.rs
+45
View File
@@ -0,0 +1,45 @@
//! The revive LLVM builder platforms.
pub mod aarch64_linux_gnu;
pub mod aarch64_linux_musl;
pub mod aarch64_macos;
pub mod shared;
pub mod wasm32_emscripten;
pub mod x86_64_linux_gnu;
pub mod x86_64_linux_musl;
pub mod x86_64_macos;
pub mod x86_64_windows_gnu;
use std::str::FromStr;
/// The list of platforms used as constants.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum Platform {
/// The native X86 platform.
X86,
/// The native AArch64 platform.
AArch64,
/// The PolkaVM RISC-V platform.
PolkaVM,
}
impl FromStr for Platform {
type Err = String;
fn from_str(value: &str) -> Result<Self, Self::Err> {
match value {
"PolkaVM" => Ok(Self::PolkaVM),
value => Err(format!("Unsupported platform: `{}`", value)),
}
}
}
impl std::fmt::Display for Platform {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
match self {
Self::X86 => write!(f, "X86"),
Self::AArch64 => write!(f, "AArch64"),
Self::PolkaVM => write!(f, "RISCV"),
}
}
}
crates/llvm-builder/src/platforms/shared.rs
+232
View File
@@ -0,0 +1,232 @@
//! The shared options for building various platforms.
use crate::ccache_variant::CcacheVariant;
use crate::sanitizer::Sanitizer;
use crate::target_env::TargetEnv;
use crate::target_triple::TargetTriple;
use std::path::Path;
use std::process::Command;
/// The build options shared by all platforms.
pub const SHARED_BUILD_OPTS: [&str; 19] = [
"-DPACKAGE_VENDOR='Parity Technologies'",
"-DCMAKE_BUILD_WITH_INSTALL_RPATH=1",
"-DLLVM_BUILD_DOCS='Off'",
"-DLLVM_INCLUDE_DOCS='Off'",
"-DLLVM_INCLUDE_BENCHMARKS='Off'",
"-DLLVM_INCLUDE_EXAMPLES='Off'",
"-DLLVM_ENABLE_DOXYGEN='Off'",
"-DLLVM_ENABLE_SPHINX='Off'",
"-DLLVM_ENABLE_OCAMLDOC='Off'",
"-DLLVM_ENABLE_ZLIB='Off'",
"-DLLVM_ENABLE_ZSTD='Off'",
"-DLLVM_ENABLE_LIBXML2='Off'",
"-DLLVM_ENABLE_BINDINGS='Off'",
"-DLLVM_ENABLE_TERMINFO='Off'",
"-DLLVM_ENABLE_LIBEDIT='Off'",
"-DLLVM_ENABLE_LIBPFM='Off'",
"-DCMAKE_EXPORT_COMPILE_COMMANDS='On'",
"-DPython3_FIND_REGISTRY='LAST'", // Use Python version from $PATH, not from registry
"-DBUG_REPORT_URL='https://github.com/paritytech/contract-issues/issues/'",
];
/// The build options shared by all platforms except MUSL.
pub const SHARED_BUILD_OPTS_NOT_MUSL: [&str; 4] = [
"-DLLVM_OPTIMIZED_TABLEGEN='On'",
"-DLLVM_BUILD_RUNTIME='Off'",
"-DLLVM_BUILD_RUNTIMES='Off'",
"-DLLVM_INCLUDE_RUNTIMES='Off'",
];
/// The shared build options to treat warnings as errors.
///
/// Disabled on Windows due to the following upstream issue with MSYS2 with mingw-w64:
/// ProgramTest.cpp:23:15: error: '__p__environ' redeclared without 'dllimport' attribute
pub fn shared_build_opts_werror(target_env: TargetEnv) -> Vec<String> {
vec![format!(
"-DLLVM_ENABLE_WERROR='{}'",
if cfg!(target_os = "windows") || target_env == TargetEnv::Emscripten {
"Off"
} else {
"On"
},
)]
}
/// The build options to set the default target.
pub fn shared_build_opts_default_target(target: Option<TargetTriple>) -> Vec<String> {
match target {
Some(target) => vec![format!(
"-DLLVM_DEFAULT_TARGET_TRIPLE='{}'",
target.to_string()
)],
None => vec![format!(
"-DLLVM_DEFAULT_TARGET_TRIPLE='{}'",
TargetTriple::PolkaVM
)],
}
}
/// The `musl` building sequence.
pub fn build_musl(build_directory: &Path, target_directory: &Path) -> anyhow::Result<()> {
std::fs::create_dir_all(build_directory)?;
std::fs::create_dir_all(target_directory)?;
crate::utils::command(
Command::new("../configure")
.current_dir(build_directory)
.arg(format!("--prefix={}", target_directory.to_string_lossy()))
.arg(format!(
"--syslibdir={}/lib/",
target_directory.to_string_lossy()
))
.arg("--enable-wrapper='clang'"),
"MUSL configuring",
)?;
crate::utils::command(
Command::new("make")
.current_dir(build_directory)
.arg("-j")
.arg(num_cpus::get().to_string()),
"MUSL building",
)?;
crate::utils::command(
Command::new("make")
.current_dir(build_directory)
.arg("install"),
"MUSL installing",
)?;
let mut include_directory = target_directory.to_path_buf();
include_directory.push("include/");
let mut asm_include_directory = include_directory.clone();
asm_include_directory.push("asm/");
std::fs::create_dir_all(asm_include_directory.as_path())?;
let mut types_header_path = asm_include_directory.clone();
types_header_path.push("types.h");
let copy_options = fs_extra::dir::CopyOptions {
overwrite: true,
copy_inside: true,
..Default::default()
};
fs_extra::dir::copy("/usr/include/linux", include_directory, &copy_options)?;
let copy_options = fs_extra::dir::CopyOptions {
overwrite: true,
copy_inside: true,
content_only: true,
..Default::default()
};
fs_extra::dir::copy(
"/usr/include/asm-generic",
asm_include_directory,
&copy_options,
)?;
crate::utils::command(
Command::new("sed")
.arg("-i")
.arg("s/asm-generic/asm/")
.arg(types_header_path),
"types_header asm signature replacement",
)?;
Ok(())
}
/// The build options to enable assertions.
pub fn shared_build_opts_assertions(enabled: bool) -> Vec<String> {
vec![format!(
"-DLLVM_ENABLE_ASSERTIONS='{}'",
if enabled { "On" } else { "Off" },
)]
}
/// The build options to build with RTTI support.
pub fn shared_build_opts_rtti(enabled: bool) -> Vec<String> {
vec![format!(
"-DLLVM_ENABLE_RTTI='{}'",
if enabled { "On" } else { "Off" },
)]
}
/// The build options to enable sanitizers.
pub fn shared_build_opts_sanitizers(sanitizer: Option<Sanitizer>) -> Vec<String> {
match sanitizer {
Some(sanitizer) => vec![format!("-DLLVM_USE_SANITIZER='{}'", sanitizer)],
None => vec![],
}
}
/// The build options to enable Valgrind for LLVM regression tests.
pub fn shared_build_opts_valgrind(enabled: bool) -> Vec<String> {
if enabled {
vec!["-DLLVM_LIT_ARGS='-sv --vg --vg-leak'".to_owned()]
} else {
vec![]
}
}
/// The LLVM tests build options shared by all platforms.
pub fn shared_build_opts_tests(enabled: bool) -> Vec<String> {
vec![
format!(
"-DLLVM_BUILD_UTILS='{}'",
if enabled { "On" } else { "Off" },
),
format!(
"-DLLVM_BUILD_TESTS='{}'",
if enabled { "On" } else { "Off" },
),
format!(
"-DLLVM_INCLUDE_UTILS='{}'",
if enabled { "On" } else { "Off" },
),
format!(
"-DLLVM_INCLUDE_TESTS='{}'",
if enabled { "On" } else { "Off" },
),
]
}
/// The code coverage build options shared by all platforms.
pub fn shared_build_opts_coverage(enabled: bool) -> Vec<String> {
vec![format!(
"-DLLVM_BUILD_INSTRUMENTED_COVERAGE='{}'",
if enabled { "On" } else { "Off" },
)]
}
/// Use of compiler cache (ccache) to speed up the build process.
pub fn shared_build_opts_ccache(ccache_variant: Option<CcacheVariant>) -> Vec<String> {
match ccache_variant {
Some(ccache_variant) => vec![
format!(
"-DCMAKE_C_COMPILER_LAUNCHER='{}'",
ccache_variant.to_string()
),
format!(
"-DCMAKE_CXX_COMPILER_LAUNCHER='{}'",
ccache_variant.to_string()
),
],
None => vec![],
}
}
/// Ignore duplicate libraries warnings for MacOS with XCode>=15.
pub fn macos_build_opts_ignore_dupicate_libs_warnings() -> Vec<String> {
let xcode_version =
crate::utils::get_xcode_version().unwrap_or(crate::utils::XCODE_MIN_VERSION);
if xcode_version >= crate::utils::XCODE_VERSION_15 {
vec![
"-DCMAKE_EXE_LINKER_FLAGS='-Wl,-no_warn_duplicate_libraries'".to_owned(),
"-DCMAKE_SHARED_LINKER_FLAGS='-Wl,-no_warn_duplicate_libraries'".to_owned(),
]
} else {
vec![]
}
}
crates/llvm-builder/src/platforms/wasm32_emscripten.rs
+224
View File
@@ -0,0 +1,224 @@
//! The revive LLVM `wasm32_unknown_emscripten` builder.
//!
//! Cross-compiling LLVM for Emscripten requires llvm-tblgen, clang-tblgen and llvm-config.
use std::{collections::HashSet, path::Path, process::Command};
/// The building sequence.
#[allow(clippy::too_many_arguments)]
pub fn build(
build_type: crate::BuildType,
targets: HashSet<crate::Platform>,
llvm_projects: HashSet<crate::llvm_project::LLVMProject>,
enable_rtti: bool,
default_target: Option<crate::TargetTriple>,
enable_tests: bool,
enable_coverage: bool,
extra_args: &[String],
ccache_variant: Option<crate::ccache_variant::CcacheVariant>,
enable_assertions: bool,
sanitizer: Option<crate::sanitizer::Sanitizer>,
enable_valgrind: bool,
) -> anyhow::Result<()> {
crate::utils::check_presence("cmake")?;
crate::utils::check_presence("ninja")?;
crate::utils::check_presence("emsdk")?;
crate::utils::check_presence("clang")?;
crate::utils::check_presence("clang++")?;
if cfg!(target_os = "linux") {
crate::utils::check_presence("lld")?;
}
let llvm_module_llvm = crate::LLVMPath::llvm_module_llvm()?;
let llvm_host_module_llvm = crate::LLVMPath::llvm_host_module_llvm()?;
let llvm_build_host = crate::LLVMPath::llvm_build_host()?;
let llvm_target_host = crate::LLVMPath::llvm_target_host()?;
let llvm_build_final = crate::LLVMPath::llvm_build_final()?;
let llvm_target_final = crate::LLVMPath::llvm_target_final()?;
build_host(
llvm_host_module_llvm.as_path(),
llvm_build_host.as_path(),
llvm_target_host.as_path(),
ccache_variant,
)?;
build_target(
build_type,
targets,
llvm_projects,
enable_rtti,
default_target,
llvm_module_llvm.as_path(),
llvm_build_final.as_path(),
llvm_target_final.as_path(),
llvm_target_host.as_path(),
enable_tests,
enable_coverage,
extra_args,
ccache_variant,
enable_assertions,
sanitizer,
enable_valgrind,
)?;
Ok(())
}
/// The host toolchain building sequence.
fn build_host(
source_directory: &Path,
build_directory: &Path,
target_directory: &Path,
ccache_variant: Option<crate::ccache_variant::CcacheVariant>,
) -> anyhow::Result<()> {
log::info!("building the LLVM Emscripten host utilities");
crate::utils::command(
Command::new("cmake")
.args([
"-S",
source_directory.to_string_lossy().as_ref(),
"-B",
build_directory.to_string_lossy().as_ref(),
"-G",
"Ninja",
"-DLINKER_SUPPORTS_COLOR_DIAGNOSTICS=0",
&format!(
"-DCMAKE_INSTALL_PREFIX='{}'",
target_directory.to_string_lossy()
),
"-DLLVM_BUILD_SHARED_LIBS='Off'",
"-DCMAKE_BUILD_TYPE='Release'",
&format!(
"-DLLVM_TARGETS_TO_BUILD='WebAssembly;{}'",
crate::Platform::PolkaVM
),
"-DLLVM_ENABLE_PROJECTS='clang;lld'",
])
.args(crate::platforms::shared::SHARED_BUILD_OPTS)
.args(crate::platforms::shared::SHARED_BUILD_OPTS_NOT_MUSL)
.args(crate::platforms::shared::shared_build_opts_ccache(
ccache_variant,
)),
"LLVM host building cmake config",
)?;
crate::utils::ninja(build_directory)?;
Ok(())
}
/// The target toolchain building sequence.
#[allow(clippy::too_many_arguments)]
fn build_target(
build_type: crate::BuildType,
targets: HashSet<crate::Platform>,
llvm_projects: HashSet<crate::llvm_project::LLVMProject>,
enable_rtti: bool,
default_target: Option<crate::TargetTriple>,
source_directory: &Path,
build_directory: &Path,
target_directory: &Path,
host_target_directory: &Path,
enable_tests: bool,
enable_coverage: bool,
extra_args: &[String],
ccache_variant: Option<crate::ccache_variant::CcacheVariant>,
enable_assertions: bool,
sanitizer: Option<crate::sanitizer::Sanitizer>,
enable_valgrind: bool,
) -> anyhow::Result<()> {
let mut llvm_tblgen_path = host_target_directory.to_path_buf();
llvm_tblgen_path.push("bin/llvm-tblgen");
let mut clang_tblgen_path = host_target_directory.to_path_buf();
clang_tblgen_path.push("bin/clang-tblgen");
crate::utils::command(
Command::new("emcmake")
.env("EMCC_DEBUG", "2")
.env("CXXFLAGS", "-Dwait4=__syscall_wait4")
.env("LDFLAGS", "-lnodefs.js -s NO_INVOKE_RUN -s EXIT_RUNTIME -s INITIAL_MEMORY=64MB -s ALLOW_MEMORY_GROWTH -s EXPORTED_RUNTIME_METHODS=FS,callMain,NODEFS -s MODULARIZE -s EXPORT_ES6 -s WASM_BIGINT")
.arg("cmake")
.args([
"-S",
source_directory.to_string_lossy().as_ref(),
"-B",
build_directory.to_string_lossy().as_ref(),
"-G",
"Ninja",
"-DLINKER_SUPPORTS_COLOR_DIAGNOSTICS=0",
"-DCMAKE_BUILD_WITH_INSTALL_RPATH=1",
// Enable thin LTO but emscripten has various issues with it.
// FIXME: https://github.com/paritytech/revive/issues/148
//"-DLLVM_ENABLE_LTO='Thin'",
//"-DCMAKE_EXE_LINKER_FLAGS='-Wl,-u,htons -Wl,-u,htonl -Wl,-u,fileno -Wl,-u,ntohs'",
&format!(
"-DCMAKE_INSTALL_PREFIX='{}'",
target_directory.to_string_lossy()
),
&format!("-DCMAKE_BUILD_TYPE='{build_type}'"),
&format!(
"-DLLVM_TARGETS_TO_BUILD='{}'",
targets
.into_iter()
.map(|platform| platform.to_string())
.collect::<Vec<String>>()
.join(";")
),
&format!(
"-DLLVM_ENABLE_PROJECTS='{}'",
llvm_projects
.into_iter()
.map(|project| project.to_string())
.collect::<Vec<String>>()
.join(";")
),
"-DLLVM_BUILD_SHARED_LIBS='Off'",
"-DLLVM_ENABLE_DUMP='Off'",
"-DLLVM_ENABLE_EXPENSIVE_CHECKS='Off'",
"-DLLVM_ENABLE_BACKTRACES='Off'",
"-DLLVM_ENABLE_BACKTRACES='Off'",
"-DLLVM_ENABLE_THREADS='Off'",
"-DLLVM_BUILD_TOOLS='Off'",
&format!("-DLLVM_TABLEGEN='{}'", llvm_tblgen_path.to_string_lossy()),
&format!("-DCLANG_TABLEGEN='{}'", clang_tblgen_path.to_string_lossy()),
])
.args(crate::platforms::shared::shared_build_opts_default_target(
default_target,
))
.args(crate::platforms::shared::SHARED_BUILD_OPTS)
.args(crate::platforms::shared::SHARED_BUILD_OPTS_NOT_MUSL)
.args(crate::platforms::shared::shared_build_opts_werror(crate::target_env::TargetEnv::Emscripten))
.args(crate::platforms::shared::shared_build_opts_tests(
enable_tests,
))
.args(crate::platforms::shared::shared_build_opts_coverage(
enable_coverage,
))
.args(extra_args)
.args(crate::platforms::shared::shared_build_opts_ccache(
ccache_variant,
))
.args(crate::platforms::shared::shared_build_opts_assertions(
enable_assertions,
))
.args(crate::platforms::shared::shared_build_opts_rtti(
enable_rtti,
))
.args(crate::platforms::shared::shared_build_opts_sanitizers(
sanitizer,
))
.args(crate::platforms::shared::shared_build_opts_valgrind(
enable_valgrind,
)),
"LLVM target building cmake",
)?;
crate::utils::ninja(build_directory)?;
Ok(())
}
crates/llvm-builder/src/platforms/x86_64_linux_gnu.rs
+111
View File
@@ -0,0 +1,111 @@
//! The revive LLVM amd64 `linux-gnu` builder.
use std::collections::HashSet;
use std::process::Command;
use crate::build_type::BuildType;
use crate::ccache_variant::CcacheVariant;
use crate::llvm_path::LLVMPath;
use crate::llvm_project::LLVMProject;
use crate::platforms::Platform;
use crate::sanitizer::Sanitizer;
use crate::target_triple::TargetTriple;
/// The building sequence.
#[allow(clippy::too_many_arguments)]
pub fn build(
build_type: BuildType,
targets: HashSet<Platform>,
llvm_projects: HashSet<LLVMProject>,
enable_rtti: bool,
default_target: Option<TargetTriple>,
enable_tests: bool,
enable_coverage: bool,
extra_args: &[String],
ccache_variant: Option<CcacheVariant>,
enable_assertions: bool,
sanitizer: Option<Sanitizer>,
enable_valgrind: bool,
) -> anyhow::Result<()> {
crate::utils::check_presence("cmake")?;
crate::utils::check_presence("clang")?;
crate::utils::check_presence("clang++")?;
crate::utils::check_presence("lld")?;
crate::utils::check_presence("ninja")?;
let llvm_module_llvm = LLVMPath::llvm_module_llvm()?;
let llvm_build_final = LLVMPath::llvm_build_final()?;
let llvm_target_final = LLVMPath::llvm_target_final()?;
crate::utils::command(
Command::new("cmake")
.args([
"-S",
llvm_module_llvm.to_string_lossy().as_ref(),
"-B",
llvm_build_final.to_string_lossy().as_ref(),
"-G",
"Ninja",
format!(
"-DCMAKE_INSTALL_PREFIX='{}'",
llvm_target_final.to_string_lossy().as_ref(),
)
.as_str(),
format!("-DCMAKE_BUILD_TYPE='{build_type}'").as_str(),
"-DCMAKE_C_COMPILER='clang'",
"-DCMAKE_CXX_COMPILER='clang++'",
format!(
"-DLLVM_TARGETS_TO_BUILD='{}'",
targets
.into_iter()
.map(|platform| platform.to_string())
.collect::<Vec<String>>()
.join(";")
)
.as_str(),
format!(
"-DLLVM_ENABLE_PROJECTS='{}'",
llvm_projects
.into_iter()
.map(|project| project.to_string())
.collect::<Vec<String>>()
.join(";")
)
.as_str(),
"-DLLVM_USE_LINKER='lld'",
])
.args(crate::platforms::shared::shared_build_opts_default_target(
default_target,
))
.args(crate::platforms::shared::shared_build_opts_tests(
enable_tests,
))
.args(crate::platforms::shared::shared_build_opts_coverage(
enable_coverage,
))
.args(crate::platforms::shared::shared_build_opts_ccache(
ccache_variant,
))
.args(crate::platforms::shared::SHARED_BUILD_OPTS)
.args(crate::platforms::shared::SHARED_BUILD_OPTS_NOT_MUSL)
.args(crate::platforms::shared::shared_build_opts_werror(
crate::target_env::TargetEnv::GNU,
))
.args(extra_args)
.args(crate::platforms::shared::shared_build_opts_assertions(
enable_assertions,
))
.args(crate::platforms::shared::shared_build_opts_rtti(
enable_rtti,
))
.args(crate::platforms::shared::shared_build_opts_sanitizers(
sanitizer,
))
.args(crate::platforms::shared::shared_build_opts_valgrind(
enable_valgrind,
)),
"LLVM building cmake",
)?;
crate::utils::ninja(llvm_build_final.as_ref())?;
Ok(())
}
crates/llvm-builder/src/platforms/x86_64_linux_musl.rs
+394
View File
@@ -0,0 +1,394 @@
//! The revive LLVM amd64 `linux-musl` builder.
use std::collections::HashSet;
use std::path::Path;
use std::process::Command;
use crate::build_type::BuildType;
use crate::ccache_variant::CcacheVariant;
use crate::llvm_path::LLVMPath;
use crate::llvm_project::LLVMProject;
use crate::platforms::Platform;
use crate::sanitizer::Sanitizer;
use crate::target_triple::TargetTriple;
/// The building sequence.
#[allow(clippy::too_many_arguments)]
pub fn build(
build_type: BuildType,
targets: HashSet<Platform>,
llvm_projects: HashSet<LLVMProject>,
enable_rtti: bool,
default_target: Option<TargetTriple>,
enable_tests: bool,
enable_coverage: bool,
extra_args: &[String],
ccache_variant: Option<CcacheVariant>,
enable_assertions: bool,
sanitizer: Option<Sanitizer>,
enable_valgrind: bool,
) -> anyhow::Result<()> {
log::info!("building for target x86_64_linux_musl");
crate::utils::check_presence("cmake")?;
crate::utils::check_presence("clang")?;
crate::utils::check_presence("clang++")?;
crate::utils::check_presence("lld")?;
crate::utils::check_presence("ninja")?;
let musl_name = "musl-1.2.3";
let musl_build = LLVMPath::musl_build(musl_name)?;
let musl_target = LLVMPath::musl_target()?;
let llvm_module_llvm = LLVMPath::llvm_module_llvm()?;
let llvm_host_module_llvm = LLVMPath::llvm_host_module_llvm()?;
let llvm_build_crt = LLVMPath::llvm_build_crt()?;
let llvm_target_crt = LLVMPath::llvm_target_crt()?;
let llvm_build_host = LLVMPath::llvm_build_host()?;
let llvm_target_host = LLVMPath::llvm_target_host()?;
let llvm_build_final = LLVMPath::llvm_build_final()?;
let llvm_target_final = LLVMPath::llvm_target_final()?;
if !LLVMPath::musl_source(musl_name)?.exists() {
crate::utils::download_musl(musl_name)?;
}
crate::platforms::shared::build_musl(musl_build.as_path(), musl_target.as_path())?;
build_crt(
targets.clone(),
llvm_host_module_llvm.as_path(),
llvm_build_crt.as_path(),
llvm_target_crt.as_path(),
ccache_variant,
)?;
build_host(
llvm_host_module_llvm.as_path(),
llvm_build_host.as_path(),
llvm_target_host.as_path(),
musl_target.as_path(),
llvm_target_crt.as_path(),
ccache_variant,
)?;
build_target(
build_type,
targets,
llvm_projects,
enable_rtti,
default_target,
llvm_module_llvm.as_path(),
llvm_build_final.as_path(),
llvm_target_final.as_path(),
musl_target.as_path(),
llvm_target_host.as_path(),
enable_tests,
enable_coverage,
extra_args,
ccache_variant,
enable_assertions,
sanitizer,
enable_valgrind,
)?;
Ok(())
}
/// The `crt` building sequence.
fn build_crt(
mut targets: HashSet<Platform>,
source_directory: &Path,
build_directory: &Path,
target_directory: &Path,
ccache_variant: Option<CcacheVariant>,
) -> anyhow::Result<()> {
targets.insert(Platform::X86);
crate::utils::command(
Command::new("cmake")
.args([
"-S",
source_directory.to_string_lossy().as_ref(),
"-B",
build_directory.to_string_lossy().as_ref(),
"-G",
"Ninja",
format!(
"-DCMAKE_INSTALL_PREFIX='{}'",
target_directory.to_string_lossy()
)
.as_str(),
"-DCMAKE_BUILD_TYPE='Release'",
"-DCMAKE_C_COMPILER='clang'",
"-DCMAKE_CXX_COMPILER='clang++'",
"-DLLVM_ENABLE_PROJECTS='compiler-rt'",
format!("-DLLVM_TARGETS_TO_BUILD='{}'", Platform::X86).as_str(),
"-DLLVM_DEFAULT_TARGET_TRIPLE='x86_64-pc-linux-musl'",
"-DLLVM_BUILD_TESTS='Off'",
"-DLLVM_BUILD_RUNTIMES='Off'",
"-DLLVM_BUILD_UTILS='Off'",
"-DLLVM_INCLUDE_TESTS='Off'",
"-DLLVM_INCLUDE_RUNTIMES='Off'",
"-DLLVM_INCLUDE_UTILS='Off'",
"-DCOMPILER_RT_DEFAULT_TARGET_ARCH='x86_64'",
"-DCOMPILER_RT_BUILD_CRT='On'",
"-DCOMPILER_RT_BUILD_SANITIZERS='Off'",
"-DCOMPILER_RT_BUILD_XRAY='Off'",
"-DCOMPILER_RT_BUILD_LIBFUZZER='Off'",
"-DCOMPILER_RT_BUILD_PROFILE='Off'",
"-DCOMPILER_RT_BUILD_MEMPROF='Off'",
"-DCOMPILER_RT_BUILD_ORC='Off'",
])
.args(crate::platforms::shared::SHARED_BUILD_OPTS)
.args(crate::platforms::shared::shared_build_opts_ccache(
ccache_variant,
)),
"CRT building cmake",
)?;
crate::utils::command(
Command::new("ninja")
.arg("-C")
.arg(build_directory)
.arg("install-crt"),
"CRT building ninja",
)?;
Ok(())
}
/// The host toolchain building sequence.
fn build_host(
source_directory: &Path,
build_directory: &Path,
target_directory: &Path,
musl_target_directory: &Path,
crt_target_directory: &Path,
ccache_variant: Option<CcacheVariant>,
) -> anyhow::Result<()> {
crate::utils::command(
Command::new("cmake")
.args([
"-S",
source_directory.to_string_lossy().as_ref(),
"-B",
build_directory.to_string_lossy().as_ref(),
"-G",
"Ninja",
format!(
"-DDEFAULT_SYSROOT='{}'",
musl_target_directory.to_string_lossy()
)
.as_str(),
"-DLINKER_SUPPORTS_COLOR_DIAGNOSTICS=0",
format!(
"-DCMAKE_INSTALL_PREFIX='{}'",
target_directory.to_string_lossy()
)
.as_str(),
"-DCMAKE_BUILD_TYPE='Release'",
"-DCMAKE_C_COMPILER='clang'",
"-DCMAKE_CXX_COMPILER='clang++'",
"-DCLANG_DEFAULT_CXX_STDLIB='libc++'",
"-DCLANG_DEFAULT_RTLIB='compiler-rt'",
"-DLLVM_DEFAULT_TARGET_TRIPLE='x86_64-pc-linux-musl'",
"-DLLVM_TARGETS_TO_BUILD='X86'",
"-DLLVM_BUILD_TESTS='Off'",
"-DLLVM_BUILD_UTILS='Off'",
"-DLLVM_INCLUDE_TESTS='Off'",
"-DLLVM_INCLUDE_UTILS='Off'",
"-DLLVM_ENABLE_PROJECTS='clang;lld'",
"-DLLVM_ENABLE_RUNTIMES='compiler-rt;libcxx;libcxxabi;libunwind'",
"-DLIBCXX_CXX_ABI='libcxxabi'",
"-DLIBCXX_HAS_MUSL_LIBC='On'",
"-DLIBCXX_ENABLE_SHARED='Off'",
"-DLIBCXX_ENABLE_STATIC='On'",
"-DLIBCXX_ENABLE_STATIC_ABI_LIBRARY='On'",
"-DLIBCXXABI_ENABLE_SHARED='Off'",
"-DLIBCXXABI_ENABLE_STATIC='On'",
"-DLIBCXXABI_ENABLE_STATIC_UNWINDER='On'",
"-DLIBCXXABI_USE_LLVM_UNWINDER='On'",
"-DLIBCXXABI_USE_COMPILER_RT='On'",
"-DLIBUNWIND_ENABLE_STATIC='On'",
"-DLIBUNWIND_ENABLE_SHARED='Off'",
"-DCOMPILER_RT_BUILD_CRT='On'",
"-DCOMPILER_RT_BUILD_SANITIZERS='Off'",
"-DCOMPILER_RT_BUILD_XRAY='Off'",
"-DCOMPILER_RT_BUILD_LIBFUZZER='Off'",
"-DCOMPILER_RT_BUILD_PROFILE='On'",
"-DCOMPILER_RT_BUILD_MEMPROF='Off'",
"-DCOMPILER_RT_BUILD_ORC='Off'",
"-DCOMPILER_RT_DEFAULT_TARGET_ARCH='x86_64'",
"-DCOMPILER_RT_DEFAULT_TARGET_ONLY='On'",
"-DLIBCLANG_BUILD_STATIC='On'",
"-DBUILD_SHARED_LIBS='Off'",
])
.args(crate::platforms::shared::SHARED_BUILD_OPTS)
.args(crate::platforms::shared::shared_build_opts_ccache(
ccache_variant,
)),
"LLVM host building cmake",
)?;
let mut crt_lib_directory = crt_target_directory.to_path_buf();
crt_lib_directory.push("lib/");
let mut build_lib_directory = build_directory.to_path_buf();
build_lib_directory.push("lib/");
let copy_options = fs_extra::dir::CopyOptions {
overwrite: true,
copy_inside: true,
content_only: true,
..Default::default()
};
fs_extra::dir::copy(crt_lib_directory, build_lib_directory, &copy_options)?;
crate::utils::command(
Command::new("ninja")
.arg("-C")
.arg(build_directory)
.arg("install"),
"LLVM host building ninja",
)?;
Ok(())
}
/// The target toolchain building sequence.
#[allow(clippy::too_many_arguments)]
fn build_target(
build_type: BuildType,
targets: HashSet<Platform>,
llvm_projects: HashSet<LLVMProject>,
enable_rtti: bool,
default_target: Option<TargetTriple>,
source_directory: &Path,
build_directory: &Path,
target_directory: &Path,
musl_target_directory: &Path,
host_target_directory: &Path,
enable_tests: bool,
enable_coverage: bool,
extra_args: &[String],
ccache_variant: Option<CcacheVariant>,
enable_assertions: bool,
sanitizer: Option<Sanitizer>,
enable_valgrind: bool,
) -> anyhow::Result<()> {
let mut clang_path = host_target_directory.to_path_buf();
clang_path.push("bin/clang");
let mut clang_cxx_path = host_target_directory.to_path_buf();
clang_cxx_path.push("bin/clang++");
crate::utils::command(
Command::new("cmake")
.args([
"-S",
source_directory.to_string_lossy().as_ref(),
"-B",
build_directory.to_string_lossy().as_ref(),
"-G",
"Ninja",
"-DBUILD_SHARED_LIBS='Off'",
"-DLIBCLANG_BUILD_STATIC='On'",
"-DLLVM_BUILD_STATIC='On'",
"-DLINKER_SUPPORTS_COLOR_DIAGNOSTICS=0",
format!(
"-DCMAKE_INSTALL_PREFIX='{}'",
target_directory.to_string_lossy()
)
.as_str(),
format!("-DCMAKE_BUILD_TYPE='{build_type}'").as_str(),
format!("-DCMAKE_C_COMPILER='{}'", clang_path.to_string_lossy()).as_str(),
format!(
"-DCMAKE_CXX_COMPILER='{}'",
clang_cxx_path.to_string_lossy()
)
.as_str(),
"-DCMAKE_FIND_LIBRARY_SUFFIXES='.a'",
"-DCMAKE_BUILD_WITH_INSTALL_RPATH=1",
"-DCMAKE_EXE_LINKER_FLAGS='-fuse-ld=lld -static'",
format!(
"-DLLVM_TARGETS_TO_BUILD='{}'",
targets
.into_iter()
.map(|platform| platform.to_string())
.collect::<Vec<String>>()
.join(";")
)
.as_str(),
format!(
"-DLLVM_ENABLE_PROJECTS='{}'",
llvm_projects
.into_iter()
.map(|project| project.to_string())
.collect::<Vec<String>>()
.join(";")
)
.as_str(),
])
.args(crate::platforms::shared::shared_build_opts_default_target(
default_target,
))
.args(crate::platforms::shared::SHARED_BUILD_OPTS)
.args(crate::platforms::shared::SHARED_BUILD_OPTS_NOT_MUSL)
.args(crate::platforms::shared::shared_build_opts_werror(
crate::target_env::TargetEnv::MUSL,
))
.args(crate::platforms::shared::shared_build_opts_tests(
enable_tests,
))
.args(crate::platforms::shared::shared_build_opts_coverage(
enable_coverage,
))
.args(extra_args)
.args(crate::platforms::shared::shared_build_opts_ccache(
ccache_variant,
))
.args(crate::platforms::shared::shared_build_opts_assertions(
enable_assertions,
))
.args(crate::platforms::shared::shared_build_opts_rtti(
enable_rtti,
))
.args(crate::platforms::shared::shared_build_opts_sanitizers(
sanitizer,
))
.args(crate::platforms::shared::shared_build_opts_valgrind(
enable_valgrind,
)),
"LLVM target building cmake",
)?;
crate::utils::ninja(build_directory)?;
let mut musl_lib_directory = musl_target_directory.to_path_buf();
musl_lib_directory.push("lib/");
let mut host_lib_directory = host_target_directory.to_path_buf();
host_lib_directory.push("lib/x86_64-pc-linux-musl/");
let mut target_lib_directory = target_directory.to_path_buf();
target_lib_directory.push("lib/");
let copy_options = fs_extra::dir::CopyOptions {
overwrite: true,
copy_inside: true,
content_only: true,
..Default::default()
};
fs_extra::dir::copy(
musl_lib_directory,
target_lib_directory.as_path(),
&copy_options,
)?;
fs_extra::dir::copy(
host_lib_directory,
target_lib_directory.as_path(),
&copy_options,
)?;
Ok(())
}
crates/llvm-builder/src/platforms/x86_64_macos.rs
+105
View File
@@ -0,0 +1,105 @@
//! The revive LLVM amd64 `macos` builder.
use std::collections::HashSet;
use std::process::Command;
use crate::build_type::BuildType;
use crate::ccache_variant::CcacheVariant;
use crate::llvm_path::LLVMPath;
use crate::llvm_project::LLVMProject;
use crate::platforms::Platform;
use crate::sanitizer::Sanitizer;
use crate::target_triple::TargetTriple;
/// The building sequence.
#[allow(clippy::too_many_arguments)]
pub fn build(
build_type: BuildType,
targets: HashSet<Platform>,
llvm_projects: HashSet<LLVMProject>,
enable_rtti: bool,
default_target: Option<TargetTriple>,
enable_tests: bool,
enable_coverage: bool,
extra_args: &[String],
ccache_variant: Option<CcacheVariant>,
enable_assertions: bool,
sanitizer: Option<Sanitizer>,
) -> anyhow::Result<()> {
crate::utils::check_presence("cmake")?;
crate::utils::check_presence("ninja")?;
let llvm_module_llvm = LLVMPath::llvm_module_llvm()?;
let llvm_build_final = LLVMPath::llvm_build_final()?;
let llvm_target_final = LLVMPath::llvm_target_final()?;
crate::utils::command(
Command::new("cmake")
.args([
"-S",
llvm_module_llvm.to_string_lossy().as_ref(),
"-B",
llvm_build_final.to_string_lossy().as_ref(),
"-G",
"Ninja",
format!(
"-DCMAKE_INSTALL_PREFIX='{}'",
llvm_target_final.to_string_lossy().as_ref(),
)
.as_str(),
format!("-DCMAKE_BUILD_TYPE='{build_type}'").as_str(),
format!(
"-DLLVM_TARGETS_TO_BUILD='{}'",
targets
.into_iter()
.map(|platform| platform.to_string())
.collect::<Vec<String>>()
.join(";")
)
.as_str(),
format!(
"-DLLVM_ENABLE_PROJECTS='{}'",
llvm_projects
.into_iter()
.map(|project| project.to_string())
.collect::<Vec<String>>()
.join(";")
)
.as_str(),
"-DCMAKE_OSX_DEPLOYMENT_TARGET='11.0'",
])
.args(crate::platforms::shared::shared_build_opts_default_target(
default_target,
))
.args(crate::platforms::shared::shared_build_opts_tests(
enable_tests,
))
.args(crate::platforms::shared::shared_build_opts_coverage(
enable_coverage,
))
.args(crate::platforms::shared::SHARED_BUILD_OPTS)
.args(crate::platforms::shared::SHARED_BUILD_OPTS_NOT_MUSL)
.args(crate::platforms::shared::shared_build_opts_werror(
crate::target_env::TargetEnv::GNU,
))
.args(extra_args)
.args(crate::platforms::shared::shared_build_opts_ccache(
ccache_variant,
))
.args(crate::platforms::shared::shared_build_opts_assertions(
enable_assertions,
))
.args(crate::platforms::shared::shared_build_opts_rtti(
enable_rtti,
))
.args(crate::platforms::shared::macos_build_opts_ignore_dupicate_libs_warnings())
.args(crate::platforms::shared::shared_build_opts_sanitizers(
sanitizer,
)),
"LLVM building cmake",
)?;
crate::utils::ninja(llvm_build_final.as_ref())?;
Ok(())
}
crates/llvm-builder/src/platforms/x86_64_windows_gnu.rs
+127
View File
@@ -0,0 +1,127 @@
//! The revive LLVM amd64 `windows-gnu` builder.
use std::collections::HashSet;
use std::path::PathBuf;
use std::process::Command;
use crate::build_type::BuildType;
use crate::ccache_variant::CcacheVariant;
use crate::llvm_path::LLVMPath;
use crate::llvm_project::LLVMProject;
use crate::platforms::Platform;
use crate::sanitizer::Sanitizer;
use crate::target_triple::TargetTriple;
/// The building sequence.
#[allow(clippy::too_many_arguments)]
pub fn build(
build_type: BuildType,
targets: HashSet<Platform>,
llvm_projects: HashSet<LLVMProject>,
enable_rtti: bool,
default_target: Option<TargetTriple>,
enable_tests: bool,
enable_coverage: bool,
extra_args: &[String],
ccache_variant: Option<CcacheVariant>,
enable_assertions: bool,
sanitizer: Option<Sanitizer>,
) -> anyhow::Result<()> {
crate::utils::check_presence("cmake")?;
crate::utils::check_presence("clang")?;
crate::utils::check_presence("clang++")?;
crate::utils::check_presence("lld")?;
crate::utils::check_presence("ninja")?;
let llvm_module_llvm =
LLVMPath::llvm_module_llvm().and_then(crate::utils::path_windows_to_unix)?;
let llvm_build_final =
LLVMPath::llvm_build_final().and_then(crate::utils::path_windows_to_unix)?;
let llvm_target_final =
LLVMPath::llvm_target_final().and_then(crate::utils::path_windows_to_unix)?;
crate::utils::command(
Command::new("cmake")
.args([
"-S",
llvm_module_llvm.to_string_lossy().as_ref(),
"-B",
llvm_build_final.to_string_lossy().as_ref(),
"-G",
"Ninja",
format!(
"-DCMAKE_INSTALL_PREFIX='{}'",
llvm_target_final.to_string_lossy().as_ref(),
)
.as_str(),
format!("-DCMAKE_BUILD_TYPE='{build_type}'").as_str(),
"-DCMAKE_C_COMPILER='clang'",
"-DCMAKE_CXX_COMPILER='clang++'",
format!(
"-DLLVM_TARGETS_TO_BUILD='{}'",
targets
.into_iter()
.map(|platform| platform.to_string())
.collect::<Vec<String>>()
.join(";")
)
.as_str(),
format!(
"-DLLVM_ENABLE_PROJECTS='{}'",
llvm_projects
.into_iter()
.map(|project| project.to_string())
.collect::<Vec<String>>()
.join(";")
)
.as_str(),
"-DLLVM_USE_LINKER='lld'",
])
.args(crate::platforms::shared::shared_build_opts_default_target(
default_target,
))
.args(crate::platforms::shared::shared_build_opts_tests(
enable_tests,
))
.args(crate::platforms::shared::shared_build_opts_coverage(
enable_coverage,
))
.args(crate::platforms::shared::SHARED_BUILD_OPTS)
.args(crate::platforms::shared::SHARED_BUILD_OPTS_NOT_MUSL)
.args(crate::platforms::shared::shared_build_opts_werror(
crate::target_env::TargetEnv::GNU,
))
.args(extra_args)
.args(crate::platforms::shared::shared_build_opts_ccache(
ccache_variant,
))
.args(crate::platforms::shared::shared_build_opts_assertions(
enable_assertions,
))
.args(crate::platforms::shared::shared_build_opts_rtti(
enable_rtti,
))
.args(crate::platforms::shared::shared_build_opts_sanitizers(
sanitizer,
)),
"LLVM building cmake",
)?;
crate::utils::ninja(llvm_build_final.as_ref())?;
let libstdcpp_source_path = match std::env::var("LIBSTDCPP_SOURCE_PATH") {
Ok(libstdcpp_source_path) => PathBuf::from(libstdcpp_source_path),
Err(error) => anyhow::bail!(
"The `LIBSTDCPP_SOURCE_PATH` must be set to the path to the libstdc++.a static library: {}", error
),
};
let mut libstdcpp_destination_path = llvm_target_final;
libstdcpp_destination_path.push("./lib/libstdc++.a");
fs_extra::file::copy(
crate::utils::path_windows_to_unix(libstdcpp_source_path)?,
crate::utils::path_windows_to_unix(libstdcpp_destination_path)?,
&fs_extra::file::CopyOptions::default(),
)?;
Ok(())
}
crates/llvm-builder/src/revive_llvm/arguments.rs
+119
View File
@@ -0,0 +1,119 @@
//! The revive LLVM builder arguments.
use clap::Parser;
use revive_llvm_builder::ccache_variant::CcacheVariant;
/// The revive LLVM builder arguments.
#[derive(Debug, Parser)]
#[command(version, about)]
pub struct Arguments {
/// Target environment to build LLVM (gnu, musl, emscripten).
#[arg(long, default_value_t = revive_llvm_builder::target_env::TargetEnv::GNU)]
pub target_env: revive_llvm_builder::target_env::TargetEnv,
#[command(subcommand)]
pub subcommand: Subcommand,
}
/// The revive LLVM builder arguments.
#[derive(Debug, clap::Subcommand)]
pub enum Subcommand {
/// Clone the branch specified in `LLVM.lock`.
Clone {
/// Clone with full commits history.
#[arg(long)]
deep: bool,
},
/// Build the LLVM framework.
Build {
/// LLVM build type (`Debug`, `Release`, `RelWithDebInfo`, or `MinSizeRel`).
#[arg(long, default_value_t = revive_llvm_builder::BuildType::Release)]
build_type: revive_llvm_builder::BuildType,
/// Additional targets to build LLVM with.
#[arg(long)]
targets: Vec<String>,
/// LLVM projects to build LLVM with.
#[arg(
long,
default_values_t = vec![
revive_llvm_builder::llvm_project::LLVMProject::CLANG,
revive_llvm_builder::llvm_project::LLVMProject::LLD
]
)]
llvm_projects: Vec<revive_llvm_builder::llvm_project::LLVMProject>,
/// Whether to build LLVM with run-time type information (RTTI) enabled.
#[arg(long)]
enable_rtti: bool,
/// The default target to build LLVM with.
#[arg(long)]
default_target: Option<revive_llvm_builder::target_triple::TargetTriple>,
/// Whether to build the LLVM tests.
#[arg(long)]
enable_tests: bool,
/// Whether to build LLVM for source-based code coverage.
#[arg(long)]
enable_coverage: bool,
/// Extra arguments to pass to CMake.
/// A leading backslash will be unescaped.
#[arg(long)]
extra_args: Vec<String>,
/// Whether to use compiler cache (ccache) to speed-up builds.
#[arg(long)]
ccache_variant: Option<CcacheVariant>,
/// Whether to build with assertions enabled or not.
#[arg(long, default_value_t = true)]
enable_assertions: bool,
/// Build LLVM with sanitizer enabled (`Address`, `Memory`, `MemoryWithOrigins`, `Undefined`, `Thread`, `DataFlow`, or `Address;Undefined`).
#[arg(long)]
sanitizer: Option<revive_llvm_builder::sanitizer::Sanitizer>,
/// Whether to run LLVM unit tests under valgrind or not.
#[arg(long)]
enable_valgrind: bool,
},
/// Checkout the branch specified in `LLVM.lock`.
Checkout {
/// Remove all artifacts preventing the checkout (removes all local changes!).
#[arg(long)]
force: bool,
},
/// Clean the build artifacts.
Clean,
/// Build the LLVM compiler-rt builtins for the PolkaVM target.
Builtins {
/// LLVM build type (`Debug`, `Release`, `RelWithDebInfo`, or `MinSizeRel`).
#[arg(long, default_value_t = revive_llvm_builder::BuildType::Release)]
build_type: revive_llvm_builder::BuildType,
/// The default target to build LLVM with.
#[arg(long)]
default_target: Option<revive_llvm_builder::target_triple::TargetTriple>,
/// Extra arguments to pass to CMake.
/// A leading backslash will be unescaped.
#[arg(long)]
extra_args: Vec<String>,
/// Whether to use compiler cache (ccache) to speed-up builds.
#[arg(long)]
ccache_variant: Option<CcacheVariant>,
/// Build LLVM with sanitizer enabled (`Address`, `Memory`, `MemoryWithOrigins`, `Undefined`, `Thread`, `DataFlow`, or `Address;Undefined`).
#[arg(long)]
sanitizer: Option<revive_llvm_builder::sanitizer::Sanitizer>,
},
}
crates/llvm-builder/src/revive_llvm/main.rs
+141
View File
@@ -0,0 +1,141 @@
//! The revive LLVM builder.
pub(crate) mod arguments;
use std::collections::HashSet;
use std::path::PathBuf;
use std::str::FromStr;
use anyhow::Context;
use clap::Parser;
use self::arguments::{Arguments, Subcommand};
fn main() {
env_logger::init();
match main_inner() {
Ok(()) => std::process::exit(0),
Err(error) => {
log::error!("{error:?}");
std::process::exit(1)
}
}
}
fn main_inner() -> anyhow::Result<()> {
let arguments = Arguments::parse();
revive_llvm_builder::utils::directory_target_llvm(arguments.target_env);
match arguments.subcommand {
Subcommand::Clone { deep } => {
let lock = revive_llvm_builder::Lock::try_from(&PathBuf::from(
revive_llvm_builder::lock::LLVM_LOCK_DEFAULT_PATH,
))?;
revive_llvm_builder::clone(lock, deep, arguments.target_env)?;
}
Subcommand::Build {
build_type,
targets,
llvm_projects,
enable_rtti,
default_target,
enable_tests,
enable_coverage,
extra_args,
ccache_variant,
enable_assertions,
sanitizer,
enable_valgrind,
} => {
let mut targets = targets
.into_iter()
.map(|target| revive_llvm_builder::Platform::from_str(target.as_str()))
.collect::<Result<HashSet<revive_llvm_builder::Platform>, String>>()
.map_err(|platform| anyhow::anyhow!("Unknown platform `{}`", platform))?;
targets.insert(revive_llvm_builder::Platform::PolkaVM);
log::info!("build targets: {:?}", &targets);
let extra_args_unescaped: Vec<String> = extra_args
.iter()
.map(|argument| {
argument
.strip_prefix('\\')
.unwrap_or(argument.as_str())
.to_owned()
})
.collect();
log::debug!("extra_args: {:#?}", extra_args);
log::debug!("extra_args_unescaped: {:#?}", extra_args_unescaped);
if let Some(ccache_variant) = ccache_variant {
revive_llvm_builder::utils::check_presence(ccache_variant.to_string().as_str())?;
}
let mut projects = llvm_projects
.into_iter()
.map(|project| {
revive_llvm_builder::llvm_project::LLVMProject::from_str(
project.to_string().as_str(),
)
})
.collect::<Result<HashSet<revive_llvm_builder::llvm_project::LLVMProject>, String>>(
)
.map_err(|project| anyhow::anyhow!("Unknown LLVM project `{}`", project))?;
projects.insert(revive_llvm_builder::llvm_project::LLVMProject::LLD);
log::info!("build projects: {:?}", &projects);
revive_llvm_builder::build(
build_type,
arguments.target_env,
targets,
projects,
enable_rtti,
default_target,
enable_tests,
enable_coverage,
&extra_args_unescaped,
ccache_variant,
enable_assertions,
sanitizer,
enable_valgrind,
)?;
}
Subcommand::Checkout { force } => {
let lock = revive_llvm_builder::Lock::try_from(&PathBuf::from(
revive_llvm_builder::lock::LLVM_LOCK_DEFAULT_PATH,
))?;
revive_llvm_builder::checkout(lock, force)?;
}
Subcommand::Clean => {
revive_llvm_builder::clean()
.with_context(|| "Unable to remove target LLVM directory")?;
}
Subcommand::Builtins {
build_type,
default_target,
extra_args,
ccache_variant,
sanitizer,
} => {
revive_llvm_builder::builtins::build(
build_type,
arguments.target_env,
default_target,
&extra_args,
ccache_variant,
sanitizer,
)?;
}
}
Ok(())
}
crates/llvm-builder/src/sanitizer.rs
+50
View File
@@ -0,0 +1,50 @@
//! LLVM sanitizers.
/// LLVM sanitizers.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum Sanitizer {
/// The address sanitizer.
Address,
/// The memory sanitizer.
Memory,
/// The memory with origins sanitizer.
MemoryWithOrigins,
/// The undefined behavior sanitizer
Undefined,
/// The thread sanitizer.
Thread,
/// The data flow sanitizer.
DataFlow,
/// Combine address and undefined behavior sanitizer.
AddressUndefined,
}
impl std::str::FromStr for Sanitizer {
type Err = String;
fn from_str(value: &str) -> Result<Self, Self::Err> {
match value.to_lowercase().as_str() {
"address" => Ok(Self::Address),
"memory" => Ok(Self::Memory),
"memorywithorigins" => Ok(Self::MemoryWithOrigins),
"undefined" => Ok(Self::Undefined),
"thread" => Ok(Self::Thread),
"dataflow" => Ok(Self::DataFlow),
"address;undefined" => Ok(Self::AddressUndefined),
value => Err(format!("Unsupported sanitizer: `{}`", value)),
}
}
}
impl std::fmt::Display for Sanitizer {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
match self {
Self::Address => write!(f, "Address"),
Self::Memory => write!(f, "Memory"),
Self::MemoryWithOrigins => write!(f, "MemoryWithOrigins"),
Self::Undefined => write!(f, "Undefined"),
Self::Thread => write!(f, "Thread"),
Self::DataFlow => write!(f, "DataFlow"),
Self::AddressUndefined => write!(f, "Address;Undefined"),
}
}
}
crates/llvm-builder/src/target_env.rs
+36
View File
@@ -0,0 +1,36 @@
//! The target environments to build LLVM.
/// The list of target environments used as constants.
#[derive(Default, Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum TargetEnv {
/// The GNU target environment.
#[default]
GNU,
/// The MUSL target environment.
MUSL,
/// The wasm32 Emscripten environment.
Emscripten,
}
impl std::str::FromStr for TargetEnv {
type Err = String;
fn from_str(value: &str) -> Result<Self, Self::Err> {
match value {
"gnu" => Ok(Self::GNU),
"musl" => Ok(Self::MUSL),
"emscripten" => Ok(Self::Emscripten),
value => Err(format!("Unsupported target environment: `{}`", value)),
}
}
}
impl std::fmt::Display for TargetEnv {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
Self::GNU => write!(f, "gnu"),
Self::MUSL => write!(f, "musl"),
Self::Emscripten => write!(f, "emscripten"),
}
}
}
crates/llvm-builder/src/target_triple.rs
+29
View File
@@ -0,0 +1,29 @@
//! The PolkaVM LLVM target triples.
/// The list of target triples used as constants.
///
/// It must be in the lowercase.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum TargetTriple {
/// The PolkaVM RISC-V target triple.
PolkaVM,
}
impl std::str::FromStr for TargetTriple {
type Err = String;
fn from_str(value: &str) -> Result<Self, Self::Err> {
match value {
"polkavm" => Ok(Self::PolkaVM),
value => Err(format!("Unsupported target triple: `{}`", value)),
}
}
}
impl std::fmt::Display for TargetTriple {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
match self {
Self::PolkaVM => write!(f, "riscv64-unknown-elf"),
}
}
}
crates/llvm-builder/src/utils.rs
+230
View File
@@ -0,0 +1,230 @@
//! The LLVM builder utilities.
use std::fs::File;
use std::path::Path;
use std::path::PathBuf;
use std::process::Command;
use std::process::Stdio;
use std::time::Duration;
use path_slash::PathBufExt;
/// The LLVM host repository URL.
pub const LLVM_HOST_SOURCE_URL: &str = "https://github.com/llvm/llvm-project";
/// The LLVM host repository tag.
pub const LLVM_HOST_SOURCE_TAG: &str = "llvmorg-18.1.8";
/// The minimum required XCode version.
pub const XCODE_MIN_VERSION: u32 = 11;
/// The XCode version 15.
pub const XCODE_VERSION_15: u32 = 15;
/// The number of download retries if failed.
pub const DOWNLOAD_RETRIES: u16 = 16;
/// The number of parallel download requests.
pub const DOWNLOAD_PARALLEL_REQUESTS: u16 = 1;
/// The download timeout in seconds.
pub const DOWNLOAD_TIMEOUT_SECONDS: u64 = 300;
/// The musl snapshots URL.
pub const MUSL_SNAPSHOTS_URL: &str = "https://git.musl-libc.org/cgit/musl/snapshot";
/// The emscripten SDK git URL.
pub const EMSDK_SOURCE_URL: &str = "https://github.com/emscripten-core/emsdk.git";
/// The emscripten SDK version.
pub const EMSDK_VERSION: &str = "3.1.64";
/// The subprocess runner.
///
/// Checks the status and prints `stderr`.
pub fn command(command: &mut Command, description: &str) -> anyhow::Result<()> {
log::debug!("executing '{command:?}' ({description})");
if std::env::var("DRY_RUN").is_ok() {
log::warn!("Only a dry run; not executing the command.");
return Ok(());
}
let status = command
.status()
.map_err(|error| anyhow::anyhow!("{} process: {}", description, error))?;
if !status.success() {
log::error!("the command '{command:?}' failed!");
anyhow::bail!("{} failed", description);
}
Ok(())
}
/// Download a file from the URL to the path.
pub fn download(url: &str, path: &str) -> anyhow::Result<()> {
log::trace!("downloading '{url}' into '{path}'");
let mut downloader = downloader::Downloader::builder()
.download_folder(Path::new(path))
.parallel_requests(DOWNLOAD_PARALLEL_REQUESTS)
.retries(DOWNLOAD_RETRIES)
.timeout(Duration::from_secs(DOWNLOAD_TIMEOUT_SECONDS))
.build()?;
while let Err(error) = downloader.download(&[downloader::Download::new(url)]) {
log::error!("MUSL download from `{url}` failed: {error}");
}
Ok(())
}
/// Unpack a tarball.
pub fn unpack_tar(filename: PathBuf, path: &str) -> anyhow::Result<()> {
let tar_gz = File::open(filename)?;
let tar = flate2::read::GzDecoder::new(tar_gz);
let mut archive = tar::Archive::new(tar);
archive.unpack(path)?;
Ok(())
}
/// The `musl` downloading sequence.
pub fn download_musl(name: &str) -> anyhow::Result<()> {
log::info!("downloading musl {name}");
let tar_file_name = format!("{name}.tar.gz");
let url = format!("{}/{tar_file_name}", MUSL_SNAPSHOTS_URL);
let target_path = crate::llvm_path::DIRECTORY_LLVM_TARGET
.get()
.unwrap()
.to_string_lossy();
download(url.as_str(), &target_path)?;
let musl_tarball = crate::LLVMPath::musl_source(tar_file_name.as_str())?;
unpack_tar(musl_tarball, &target_path)?;
Ok(())
}
/// Call ninja to build the LLVM.
pub fn ninja(build_dir: &Path) -> anyhow::Result<()> {
let mut ninja = Command::new("ninja");
ninja.args(["-C", build_dir.to_string_lossy().as_ref()]);
if std::env::var("DRY_RUN").is_ok() {
ninja.arg("-n");
}
command(ninja.arg("install"), "Running ninja install")?;
Ok(())
}
/// Create an absolute path, appending it to the current working directory.
pub fn absolute_path<P: AsRef<Path>>(path: P) -> anyhow::Result<PathBuf> {
let mut full_path = std::env::current_dir()?;
full_path.push(path);
Ok(full_path)
}
///
/// Converts a Windows path into a Unix path.
///
pub fn path_windows_to_unix<P: AsRef<Path> + PathBufExt>(path: P) -> anyhow::Result<PathBuf> {
path.to_slash()
.map(|pathbuf| PathBuf::from(pathbuf.to_string()))
.ok_or_else(|| anyhow::anyhow!("Windows-to-Unix path conversion error"))
}
/// Checks if the tool exists in the system.
pub fn check_presence(name: &str) -> anyhow::Result<()> {
let description = &format!("checking the `{name}` executable");
log::info!("{description}");
command(Command::new("which").arg(name), description)
.map_err(|_| anyhow::anyhow!("Tool `{}` is missing. Please install", name))
}
/// Identify XCode version using `pkgutil`.
pub fn get_xcode_version() -> anyhow::Result<u32> {
let pkgutil = Command::new("pkgutil")
.args(["--pkg-info", "com.apple.pkg.CLTools_Executables"])
.stdout(Stdio::piped())
.spawn()
.map_err(|error| anyhow::anyhow!("`pkgutil` process: {}", error))?;
let grep_version = Command::new("grep")
.arg("version")
.stdin(Stdio::from(pkgutil.stdout.expect(
"Failed to identify XCode version - XCode or CLI tools are not installed",
)))
.output()
.map_err(|error| anyhow::anyhow!("`grep` process: {}", error))?;
let version_string = String::from_utf8(grep_version.stdout)?;
let version_regex = regex::Regex::new(r"version: (\d+)\..*")?;
let captures = version_regex
.captures(version_string.as_str())
.ok_or(anyhow::anyhow!(
"Failed to parse XCode version: {version_string}"
))?;
let xcode_version: u32 = captures
.get(1)
.expect("Always has a major version")
.as_str()
.parse()
.map_err(|error| anyhow::anyhow!("Failed to parse XCode version: {error}"))?;
Ok(xcode_version)
}
/// Install the Emscripten SDK.
pub fn install_emsdk() -> anyhow::Result<()> {
log::info!("installing emsdk v{EMSDK_VERSION}");
let emsdk_source_path = PathBuf::from(crate::LLVMPath::DIRECTORY_EMSDK_SOURCE);
if emsdk_source_path.exists() {
log::warn!(
"emsdk source path {emsdk_source_path:?} already exists.
Skipping the emsdk installation, delete the source path for re-installation"
);
return Ok(());
}
crate::utils::command(
Command::new("git")
.arg("clone")
.arg(crate::utils::EMSDK_SOURCE_URL)
.arg(emsdk_source_path.to_string_lossy().as_ref()),
"Emscripten SDK repository cloning",
)?;
crate::utils::command(
Command::new("git")
.arg("checkout")
.arg(format!("tags/{}", crate::utils::EMSDK_VERSION))
.current_dir(&emsdk_source_path),
"Emscripten SDK repository version checkout",
)?;
crate::utils::command(
Command::new("./emsdk")
.arg("install")
.arg(EMSDK_VERSION)
.current_dir(&emsdk_source_path),
"Emscripten SDK installation",
)?;
crate::utils::command(
Command::new("./emsdk")
.arg("activate")
.arg(EMSDK_VERSION)
.current_dir(&emsdk_source_path),
"Emscripten SDK activation",
)?;
log::warn!(
"run 'source {}emsdk_env.sh' to finish the emsdk installation",
emsdk_source_path.display()
);
Ok(())
}
/// The LLVM target directory default path.
pub fn directory_target_llvm(target_env: crate::target_env::TargetEnv) -> PathBuf {
crate::llvm_path::DIRECTORY_LLVM_TARGET
.get_or_init(|| PathBuf::from(format!("./target-llvm/{}/", target_env)))
.clone()
}
crates/llvm-builder/tests/build.rs
+158
View File
@@ -0,0 +1,158 @@
pub mod common;
use std::process::Command;
use assert_cmd::prelude::*;
/// This test verifies that the LLVM repository can be successfully cloned, built, and cleaned.
#[test]
fn clone_build_and_clean() -> anyhow::Result<()> {
let test_dir = common::TestDir::with_lockfile(None)?;
Command::cargo_bin(common::REVIVE_LLVM)?
.current_dir(test_dir.path())
.arg("clone")
.assert()
.success();
Command::cargo_bin(common::REVIVE_LLVM)?
.current_dir(test_dir.path())
.arg("build")
.arg("--llvm-projects")
.arg("clang")
.arg("--llvm-projects")
.arg("lld")
.assert()
.success();
Command::cargo_bin(common::REVIVE_LLVM)?
.current_dir(test_dir.path())
.arg("builtins")
.assert()
.success();
Command::cargo_bin(common::REVIVE_LLVM)?
.current_dir(test_dir.path())
.arg("clean")
.assert()
.success();
Ok(())
}
/// This test verifies that the LLVM repository can be successfully cloned, built, and cleaned
/// with 2-staged build using MUSL as sysroot.
#[test]
#[cfg(target_os = "linux")]
fn clone_build_and_clean_musl() -> anyhow::Result<()> {
let test_dir = common::TestDir::with_lockfile(None)?;
Command::cargo_bin(common::REVIVE_LLVM)?
.arg("clone")
.current_dir(test_dir.path())
.assert()
.success();
Command::cargo_bin(common::REVIVE_LLVM)?
.arg("--target-env")
.arg("musl")
.arg("build")
.arg("--llvm-projects")
.arg("clang")
.arg("--llvm-projects")
.arg("lld")
.current_dir(test_dir.path())
.assert()
.success();
Command::cargo_bin(common::REVIVE_LLVM)?
.current_dir(test_dir.path())
.arg("builtins")
.assert()
.success();
Command::cargo_bin(common::REVIVE_LLVM)?
.current_dir(test_dir.path())
.arg("clean")
.assert()
.success();
Ok(())
}
/// This test verifies that the LLVM repository can be successfully cloned and built in debug mode
/// with tests and coverage enabled.
#[test]
fn debug_build_with_tests_coverage() -> anyhow::Result<()> {
let test_dir = common::TestDir::with_lockfile(None)?;
Command::cargo_bin(common::REVIVE_LLVM)?
.current_dir(test_dir.path())
.arg("clone")
.assert()
.success();
Command::cargo_bin(common::REVIVE_LLVM)?
.current_dir(test_dir.path())
.arg("build")
.arg("--enable-coverage")
.arg("--enable-tests")
.arg("--build-type")
.arg("Debug")
.assert()
.success();
Ok(())
}
/// This test verifies that the LLVM repository can be successfully built with address sanitizer.
#[test]
fn build_with_sanitizers() -> anyhow::Result<()> {
let test_dir = common::TestDir::with_lockfile(None)?;
Command::cargo_bin(common::REVIVE_LLVM)?
.current_dir(test_dir.path())
.arg("clone")
.assert()
.success();
Command::cargo_bin(common::REVIVE_LLVM)?
.current_dir(test_dir.path())
.arg("build")
.arg("--sanitizer")
.arg("Address")
.assert()
.success();
Ok(())
}
/// Tests the clone, build, and clean process of the LLVM repository for the emscripten target.
#[test]
#[cfg(any(target_os = "linux", target_os = "macos"))]
fn clone_build_and_clean_emscripten() -> anyhow::Result<()> {
let test_dir = common::TestDir::with_lockfile(None)?;
let command = Command::cargo_bin(common::REVIVE_LLVM)?;
let program = command.get_program().to_string_lossy();
let emsdk_wrapped_build_command = format!(
"{program} --target-env emscripten clone && \
source {}emsdk_env.sh && \
{program} --target-env emscripten build --llvm-projects clang --llvm-projects lld",
revive_llvm_builder::LLVMPath::DIRECTORY_EMSDK_SOURCE,
);
Command::new("sh")
.arg("-c")
.arg(emsdk_wrapped_build_command)
.current_dir(test_dir.path())
.assert()
.success();
Command::cargo_bin(common::REVIVE_LLVM)?
.arg("clean")
.current_dir(test_dir.path())
.assert()
.success();
Ok(())
}
crates/llvm-builder/tests/checkout.rs
+48
View File
@@ -0,0 +1,48 @@
pub mod common;
use std::process::Command;
use assert_cmd::prelude::*;
/// This test verifies that after cloning the LLVM repository, checking out a specific branch
/// or reference works as expected.
#[test]
fn checkout_after_clone() -> anyhow::Result<()> {
let test_dir = common::TestDir::with_lockfile(None)?;
Command::cargo_bin(common::REVIVE_LLVM)?
.current_dir(test_dir.path())
.arg("clone")
.assert()
.success();
Command::cargo_bin(common::REVIVE_LLVM)?
.current_dir(test_dir.path())
.arg("checkout")
.assert()
.success();
Ok(())
}
/// This test verifies that after cloning the LLVM repository, checking out a specific branch
/// or reference with the `--force` option works as expected.
#[test]
fn force_checkout() -> anyhow::Result<()> {
let test_dir = common::TestDir::with_lockfile(None)?;
Command::cargo_bin(common::REVIVE_LLVM)?
.current_dir(test_dir.path())
.arg("clone")
.assert()
.success();
Command::cargo_bin(common::REVIVE_LLVM)?
.current_dir(test_dir.path())
.arg("checkout")
.arg("--force")
.assert()
.success();
Ok(())
}
crates/llvm-builder/tests/clone.rs
+36
View File
@@ -0,0 +1,36 @@
pub mod common;
use std::process::Command;
use assert_cmd::prelude::*;
/// This test verifies that the LLVM repository can be successfully cloned using a specific branch
/// and reference.
#[test]
fn clone() -> anyhow::Result<()> {
let test_dir = common::TestDir::with_lockfile(None)?;
Command::cargo_bin(common::REVIVE_LLVM)?
.current_dir(test_dir.path())
.arg("clone")
.assert()
.success();
Ok(())
}
/// This test verifies that the LLVM repository can be successfully cloned using a specific branch
/// and reference with --deep option.
#[test]
fn clone_deep() -> anyhow::Result<()> {
let test_dir = common::TestDir::with_lockfile(None)?;
Command::cargo_bin(common::REVIVE_LLVM)?
.current_dir(test_dir.path())
.arg("clone")
.arg("--deep")
.assert()
.success();
Ok(())
}
crates/llvm-builder/tests/common.rs
+36
View File
@@ -0,0 +1,36 @@
use assert_fs::fixture::FileWriteStr;
pub const REVIVE_LLVM: &str = "revive-llvm";
pub const REVIVE_LLVM_REPO_URL: &str = "https://github.com/llvm/llvm-project";
pub const REVIVE_LLVM_REPO_TEST_BRANCH: &str = "release/18.x";
pub struct TestDir {
_lockfile: assert_fs::NamedTempFile,
path: std::path::PathBuf,
}
/// Creates a temporary lock file for testing.
impl TestDir {
pub fn with_lockfile(reference: Option<String>) -> anyhow::Result<Self> {
let file =
assert_fs::NamedTempFile::new(revive_llvm_builder::lock::LLVM_LOCK_DEFAULT_PATH)?;
let lock = revive_llvm_builder::Lock {
url: REVIVE_LLVM_REPO_URL.to_string(),
branch: REVIVE_LLVM_REPO_TEST_BRANCH.to_string(),
r#ref: reference,
};
file.write_str(toml::to_string(&lock)?.as_str())?;
Ok(Self {
path: file
.parent()
.expect("lockfile parent dir always exists")
.into(),
_lockfile: file,
})
}
pub fn path(&self) -> &std::path::Path {
&self.path
}
}
crates/runner/Cargo.toml
+1
View File
@@ -8,6 +8,7 @@ authors.workspace = true
description = "Execute revive contracts in a simulated blockchain runtime"
[features]
std = ["polkadot-sdk/std"]
default = ["solidity"]
solidity = ["revive-solidity", "revive-differential"]
crates/runtime-api/Cargo.toml
+3
View File
@@ -12,3 +12,6 @@ anyhow = { workspace = true }
inkwell = { workspace = true, features = ["target-riscv", "no-libffi-linking", "llvm18-0"] }
revive-common = { workspace = true }
[build-dependencies]
revive-build-utils = { workspace = true }
crates/runtime-api/build.rs
+7 -2
View File
@@ -14,7 +14,7 @@ const EXPORTS_BC: &str = "polkavm_exports.bc";
const EXPORTS_RUST: &str = "polkavm_exports.rs";
fn compile(source_path: &str, bitcode_path: &str) {
let output = Command::new("clang")
let output = Command::new(revive_build_utils::llvm_host_tool("clang"))
.args([
TARGET_FLAG,
"-Xclang",
@@ -37,7 +37,7 @@ fn compile(source_path: &str, bitcode_path: &str) {
source_path,
])
.output()
.expect("should be able to invoke C clang");
.unwrap_or_else(|error| panic!("failed to execute clang: {}", error));
assert!(
output.status.success(),
@@ -59,6 +59,11 @@ fn build_module(source_path: &str, bitcode_path: &str, rust_file: &str) {
}
fn main() {
println!(
"cargo:rerun-if-env-changed={}",
revive_build_utils::REVIVE_LLVM_HOST_PREFIX
);
build_module(IMPORTS_SOUCE, IMPORTS_BC, IMPORTS_RUST);
build_module(EXPORTS_SOUCE, EXPORTS_BC, EXPORTS_RUST);
crates/stdlib/Cargo.toml
+3
View File
@@ -8,3 +8,6 @@ description = "revive compiler stdlib components"
[dependencies]
inkwell = { workspace = true, features = ["target-riscv", "no-libffi-linking", "llvm18-0"] }
[build-dependencies]
revive-build-utils = { workspace = true }
crates/stdlib/build.rs
+8 -3
View File
@@ -1,18 +1,23 @@
use std::{env, fs, path::Path, process::Command};
fn main() {
println!(
"cargo:rerun-if-env-changed={}",
revive_build_utils::REVIVE_LLVM_HOST_PREFIX
);
let lib = "stdlib.bc";
let out_dir = env::var_os("OUT_DIR").expect("env should have $OUT_DIR");
let bitcode_path = Path::new(&out_dir).join(lib);
let output = Command::new("llvm-as")
let llvm_as = revive_build_utils::llvm_host_tool("llvm-as");
let output = Command::new(llvm_as)
.args([
"-o",
bitcode_path.to_str().expect("$OUT_DIR should be UTF-8"),
"stdlib.ll",
])
.output()
.expect("should be able to invoke llvm-as");
.unwrap_or_else(|error| panic!("failed to execute llvm-as: {}", error));
assert!(
output.status.success(),