Crate cc

A library for Cargo build scripts to compile a set of C/C++/assembly/CUDA files into a static archive for Cargo to link into the crate being built. This crate does not compile code itself; it calls out to the default compiler for the platform. This crate will automatically detect situations such as cross compilation and various environment variables and will build code appropriately.

Example

First, you'll want to both add a build script for your crate (build.rs) and also add this crate to your Cargo.toml via:

[build-dependencies]
cc = "1.0"

Next up, you'll want to write a build script like so:

// build.rs
cc::Build::new()
    .file("foo.c")
    .file("bar.c")
    .compile("foo");

And that's it! Running cargo build should take care of the rest and your Rust application will now have the C files foo.c and bar.c compiled into a file named libfoo.a. If the C files contain

void foo_function(void) { ... }

and

int32_t bar_function(int32_t x) { ... }

you can call them from Rust by declaring them in your Rust code like so:

extern "C" {
    fn foo_function();
    fn bar_function(x: i32) -> i32;
}

pub fn call() {
    unsafe {
        foo_function();
        bar_function(42);
    }
}

fn main() {
    call();
}

See the Rustonomicon for more details.

External configuration via environment variables

To control the programs and flags used for building, the builder can set a number of different environment variables.

Furthermore, projects using this crate may specify custom environment variables to be inspected, for example via the Build::try_flags_from_environment function. Consult the project’s own documentation or its use of the cc crate for any additional variables it may use.

Each of these variables can also be supplied with certain prefixes and suffixes, in the following prioritized order:

  1. <var>_<target> - for example, CC_x86_64-unknown-linux-gnu or CC_thumbv8m.main-none-eabi
  2. <var>_<target_with_underscores> - for example, CC_x86_64_unknown_linux_gnu or CC_thumbv8m_main_none_eabi (both periods and underscores are replaced)
  3. <build-kind>_<var> - for example, HOST_CC or TARGET_CFLAGS
  4. <var> - a plain CC, AR as above.

If none of these variables exist, cc-rs uses built-in defaults.

In addition to the above optional environment variables, cc-rs has some functions with hard requirements on some variables supplied by cargo's build-script driver that it has the TARGET, OUT_DIR, OPT_LEVEL, and HOST variables.

Optional features

Parallel

Currently cc-rs supports parallel compilation (think make -jN) but this feature is turned off by default. To enable cc-rs to compile C/C++ in parallel, you can change your dependency to:

[build-dependencies]
cc = { version = "1.0", features = ["parallel"] }

By default cc-rs will limit parallelism to $NUM_JOBS, or if not present it will limit it to the number of cpus on the machine. If you are using cargo, use -jN option of build, test and run commands as $NUM_JOBS is supplied by cargo.

Compile-time Requirements

To work properly this crate needs access to a C compiler when the build script is being run. This crate does not ship a C compiler with it. The compiler required varies per platform, but there are three broad categories:

C++ support

cc-rs supports C++ libraries compilation by using the cpp method on Build:

cc::Build::new()
    .cpp(true) // Switch to C++ library compilation.
    .file("foo.cpp")
    .compile("foo");

For C++ libraries, the CXX and CXXFLAGS environment variables are used instead of CC and CFLAGS.

The C++ standard library may be linked to the crate target. By default it's libc++ for macOS, FreeBSD, and OpenBSD, libc++_shared for Android, nothing for MSVC, and libstdc++ for anything else. It can be changed in one of two ways:

  1. by using the cpp_link_stdlib method on Build:
cc::Build::new()
    .cpp(true)
    .file("foo.cpp")
    .cpp_link_stdlib("stdc++") // use libstdc++
    .compile("foo");
  1. by setting the CXXSTDLIB environment variable.

In particular, for Android you may want to use c++_static if you have at most one shared library.

Remember that C++ does name mangling so extern "C" might be required to enable Rust linker to find your functions.

CUDA C++ support

cc-rs also supports compiling CUDA C++ libraries by using the cuda method on Build:

cc::Build::new()
    // Switch to CUDA C++ library compilation using NVCC.
    .cuda(true)
    .cudart("static")
    // Generate code for Maxwell (GTX 970, 980, 980 Ti, Titan X).
    .flag("-gencode").flag("arch=compute_52,code=sm_52")
    // Generate code for Maxwell (Jetson TX1).
    .flag("-gencode").flag("arch=compute_53,code=sm_53")
    // Generate code for Pascal (GTX 1070, 1080, 1080 Ti, Titan Xp).
    .flag("-gencode").flag("arch=compute_61,code=sm_61")
    // Generate code for Pascal (Tesla P100).
    .flag("-gencode").flag("arch=compute_60,code=sm_60")
    // Generate code for Pascal (Jetson TX2).
    .flag("-gencode").flag("arch=compute_62,code=sm_62")
    // Generate code in parallel
    .flag("-t0")
    .file("bar.cu")
    .compile("bar");

Speed up compilation with sccache

cc-rs does not handle incremental compilation like make or ninja. It always compiles the all sources, no matter if they have changed or not. This would be time-consuming in large projects. To save compilation time, you can use sccache by setting environment variable RUSTC_WRAPPER=sccache, which will use cached .o files if the sources are unchanged.

Modules

Structs