pezkuwichain/revive
1
0
Fork 0
mirror of https://github.com/pezkuwichain/revive.git synced 2026-06-09 20:01:05 +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/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()
}