Add --link-builtins flag

Author: bbqsrc

CHANGELOG.md

@@ -11,6 +11,7 @@ This version of `cargo-ndk` is much closer to a thin passthrough to `cargo` than
 - **Breaking change**: Removed Cargo.toml-based configuration property handling
 - **Breaking change**: Bump minimum supported Rust version (MSRV) to 1.86 and use Rust edition 2024.
 - **Breaking change**: `--bindgen` has been removed, and relevant environment variables are set by default
+- Enhancement: Clang builtins can now be linked automatically by adding `--link-builtins` or its equivalent environment variable
 - Enhancement: Can now be built for an Android host (i.e. Termux) if built with `CARGO_NDK_ON_ANDROID` environment variable set
 - Enhancement: CLI flags can now be used in any order (e.g., `cargo ndk -t x86 build` and `cargo ndk build --target x86` are equivalent).
 - Enhancement: Added environment variable support for configuration flags with `CARGO_NDK_` prefix (e.g., `CARGO_NDK_TARGET`, `CARGO_NDK_PLATFORM`, `CARGO_NDK_OUTPUT_DIR`)

src/bin/cargo-ndk.rs

@@ -15,19 +15,29 @@ use std::process::exit;
 /// Cargo.
 fn clang_linker_wrapper() -> ! {
     let args = std::env::args_os().skip(1);
+
     let clang = std::env::var("_CARGO_NDK_LINK_CLANG")
         .expect("cargo-ndk rustc linker: didn't find _CARGO_NDK_LINK_CLANG env var");
     let target = std::env::var("_CARGO_NDK_LINK_TARGET")
         .expect("cargo-ndk rustc linker: didn't find _CARGO_NDK_LINK_TARGET env var");
 
-    let mut child = std::process::Command::new(&clang)
-        .arg(target)
-        .args(args)
-        .spawn()
-        .unwrap_or_else(|err| {
-            eprintln!("cargo-ndk: Failed to spawn {clang:?} as linker: {err}");
-            std::process::exit(1)
-        });
+    let mut cmd = std::process::Command::new(&clang);
+    cmd.arg(target);
+
+    if let Ok(builtins_path) = std::env::var("_CARGO_NDK_LINK_BUILTINS") {
+        cmd.arg(format!("-L{}", builtins_path));
+
+        // Extract arch from target triple (e.g., "aarch64-linux-android21" -> "aarch64")
+        let arch = std::env::var("CARGO_NDK_SYSROOT_TARGET")
+            .expect("cargo-ndk rustc linker: didn't find CARGO_NDK_SYSROOT_TARGET");
+        let arch = arch.split('-').next().unwrap();
+        cmd.arg(format!("-lclang_rt.builtins-{}-android", arch));
+    }
+
+    let mut child = cmd.args(args).spawn().unwrap_or_else(|err| {
+        eprintln!("cargo-ndk: Failed to spawn {clang:?} as linker: {err}");
+        std::process::exit(1)
+    });
     let status = child.wait().unwrap_or_else(|err| {
         eprintln!("cargo-ndk (as linker): Failed to wait for {clang:?} to complete: {err}");
         std::process::exit(1);

src/cargo.rs

@@ -8,7 +8,7 @@ use std::{
 };
 
 use anyhow::{Context, Result};
-use cargo_metadata::{Artifact, Message, camino::Utf8PathBuf, semver::Version};
+use cargo_metadata::{Artifact, Message, semver::Version};
 
 use crate::shell::Shell;
 
@@ -86,10 +86,35 @@ fn cc_env(var_base: &str, triple: &str) -> (String, Option<String>) {
         .unwrap_or_else(|| (most_specific_key, None))
 }
 
+#[inline]
+// {}/toolchains/llvm/prebuilt/{ARCH}/lib/clang/{clang_version}/lib/linux
+fn clang_lib_path(ndk_home: &Path) -> PathBuf {
+    let clang_folder: PathBuf = ndk_home
+        .join("toolchains")
+        .join("llvm")
+        .join("prebuilt")
+        .join(ARCH)
+        .join("lib")
+        .join("clang");
+
+    let clang_lib_version = std::fs::read_dir(&clang_folder)
+        .expect("Unable to get clang target directory")
+        .filter_map(|a| a.ok())
+        .max_by(|a, b| a.file_name().cmp(&b.file_name()))
+        .expect("Unable to get clang target")
+        .path();
+
+    clang_folder
+        .join(clang_lib_version)
+        .join("lib")
+        .join("linux")
+}
+
 pub(crate) fn build_env(
     triple: &str,
     ndk_home: &Path,
     clang_target: &str,
+    link_builtins: bool,
 ) -> BTreeMap<String, OsString> {
     let self_path = std::fs::canonicalize(env::args().next().unwrap())
         .expect("Failed to canonicalize absolute path to cargo-ndk")
@@ -168,6 +193,11 @@ pub(crate) fn build_env(
     .into_iter()
     .collect::<BTreeMap<String, OsString>>();
 
+    if link_builtins {
+        let builtins_path = clang_lib_path(ndk_home);
+        envs.insert("_CARGO_NDK_LINK_BUILTINS".to_string(), builtins_path.into());
+    }
+
     if env::var("MSYSTEM").is_ok() || env::var("CYGWIN").is_ok() {
         envs = envs
             .into_iter()
@@ -214,9 +244,9 @@ pub(crate) fn run(
     version: &Version,
     triple: &str,
     platform: u8,
+    link_builtins: bool,
     cargo_args: &[String],
     cargo_manifest: &Path,
-    #[allow(unused_variables)] out_dir: &Utf8PathBuf,
 ) -> Result<(std::process::ExitStatus, Vec<Artifact>)> {
     if version.major < 23 {
         shell.error("NDK versions less than r23 are not supported. Install an up-to-date version of the NDK.").unwrap();
@@ -235,7 +265,7 @@ pub(crate) fn run(
     let clang_target = clang_target(triple, platform);
     let cargo_bin = env::var("CARGO").unwrap_or_else(|_| "cargo".into());
     let mut cargo_cmd = Command::new(&cargo_bin);
-    let envs = build_env(triple, ndk_home, &clang_target);
+    let envs = build_env(triple, ndk_home, &clang_target, link_builtins);
 
     shell
         .very_verbose(|shell| {

src/cli.rs

@@ -35,6 +35,10 @@ struct ArgsEnv {
     #[arg(long, default_value_t = 21, env = "CARGO_NDK_PLATFORM")]
     platform: u8,
 
+    /// Links Clang builtins library
+    #[arg(long, default_value_t = false, env = "CARGO_NDK_LINK_BUILTINS")]
+    link_builtins: bool,
+
     /// use PowerShell syntax
     #[arg(long)]
     powershell: bool,
@@ -54,6 +58,10 @@ struct Args {
     #[arg(long, default_value_t = 21, env = "CARGO_NDK_PLATFORM")]
     platform: u8,
 
+    /// Links Clang builtins library
+    #[arg(long, default_value_t = false, env = "CARGO_NDK_LINK_BUILTINS")]
+    link_builtins: bool,
+
     /// output to a jniLibs directory in the correct sub-directories
     #[arg(short, long, value_name = "DIR", env = "CARGO_NDK_OUTPUT_DIR")]
     output_dir: Option<PathBuf>,
@@ -331,10 +339,15 @@ pub fn run_env(args: Vec<String>) -> anyhow::Result<()> {
     let clang_target = clang_target(args.target.triple(), args.platform);
 
     // Try command line, then config. Config falls back to defaults in any case.
-    let env = build_env(args.target.triple(), &ndk_home, &clang_target)
-        .into_iter()
-        .filter(|(k, _)| !k.starts_with('_'))
-        .collect::<BTreeMap<_, _>>();
+    let env = build_env(
+        args.target.triple(),
+        &ndk_home,
+        &clang_target,
+        args.link_builtins,
+    )
+    .into_iter()
+    .filter(|(k, _)| !k.starts_with('_'))
+    .collect::<BTreeMap<_, _>>();
 
     if args.json {
         println!(
@@ -719,9 +732,9 @@ pub fn run(args: Vec<String>) -> anyhow::Result<()> {
                 &ndk_version,
                 triple,
                 platform,
+                args.link_builtins,
                 &args.cargo_args,
                 &cargo_manifest,
-                &out_dir,
             )?;
             let code = status.code().unwrap_or(-1);