Toolchain

toolchain.h

class Toolchain : public buildcc::internal::FlagApi<Toolchain>, public buildcc::ToolchainFind<Toolchain>, public buildcc::ToolchainVerify<Toolchain>

Subclassed by MockToolchain, buildcc::Toolchain_custom, buildcc::Toolchain_gcc, buildcc::Toolchain_mingw, buildcc::Toolchain_msvc

Public Functions

inline Toolchain(ToolchainId id, std::string_view name, const ToolchainExecutables &executables, const ToolchainConfig &config = ToolchainConfig())

virtual ~Toolchain() = default

Toolchain(Toolchain&&) = default

Toolchain &operator=(Toolchain&&) = default

Toolchain(const Toolchain&) = delete

Toolchain &operator=(const Toolchain&) = delete

inline ToolchainId GetId() const

inline const std::string &GetName() const

inline const std::string &GetAssembler() const

inline const std::string &GetCCompiler() const

inline const std::string &GetCppCompiler() const

inline const std::string &GetArchiver() const

inline const std::string &GetLinker() const

inline const ToolchainExecutables &GetToolchainExecutables() const

inline const ToolchainConfig &GetConfig() const

Friends

friend class internal::FlagApi< Toolchain >

typedef Toolchain buildcc::BaseToolchain

toolchain_find.h

template<typename T>
class ToolchainFind

Public Functions

std::vector<fs::path> Find(const ToolchainFindConfig &config = ToolchainFindConfig()) const

struct ToolchainFindConfig

Configure the behaviour of Toolchain::Find API. By default searches the directories mentioned in the ENV{PATH} variable to find the toolchain.

Param absolute_search_paths:

absolute_search_paths expect directories that are iterated for exact toolchain matches

Param env_vars:

env_vars contain paths that are seperated by OS delimiter. These are converted to paths and searched similarly to absolute_search_paths

NOTE: env_vars must contain single absolute paths or multiple absolute paths seperated by OS delimiter

Example: [Windows] “absolute_path_1;absolute_path_2;…”

Example: [Linux] “absolute_path_1:absolute_path_2:…”

Public Functions

inline ToolchainFindConfig(const std::vector<std::string> &env_vars = {"PATH"}, const std::vector<fs::path> &absolute_search_paths = {})

Public Members

std::vector<std::string> env_vars

std::vector<fs::path> absolute_search_paths

toolchain_verify.h

template<typename T>
class ToolchainVerify

Public Functions

ToolchainVerify() = default

ToolchainCompilerInfo Verify(const ToolchainFindConfig &config = ToolchainFindConfig())

Verify your toolchain executables by searching your operating system paths Only add the verified path IF all toolchain executables are matched.

Parameters:

config – Search paths to find toolchains

Returns:

std::vector<VerifiedToolchain> Operating system can contain multiple toolchains of similar names with different versions. Collect all of them

void SetToolchainInfoCb(const ToolchainInfoCb &cb)

Set ToolchainInfo callback for run time objects.

const ToolchainInfoCb &GetToolchainInfoCb() const

struct ToolchainCompilerInfo

Verified Toolchain information.

Param path:

Absolute host path where ALL the toolchain executables are found

NOTE: All the

Toolchain executables must be found in a single folder.

Param compiler_version:

Compiler version of the verified toolchain

Param target_arch:

Target architecture of the verified toolchain

Public Functions

inline std::string ToString() const

Public Members

fs::path path

std::string compiler_version

std::string target_arch

Example for Default Toolchain

BaseToolchain arm_gcc(ToolchainId::Gcc, "arm-none-eabi-gcc", "arm-none-eabi-as", "arm-none-eabi-gcc", "arm-none-eabi-g++", "arm-none-eabi-ar", "arm-none-eabi-ld");

// Toolchain::Find is only used to return a list of paths where the ToolchainExecutables are found
// NOTE: All ToolchainExecutables must be found in a single directory for it to be present in the list
{
    ToolchainFindConfig find_config;
    // Modify it here if needed
    auto found_toolchains = arm_gcc.Find(find_config);
}

// Runs Toolchain::Find
// Selects first found toolchain (update ToolchainVerifyConfig if you want to select a different toolchain for verification)
// Runs a pre-added ToolchainId::GCC verification function
// If Verification Fails: Terminates the program
// Else: Updates the arm_gcc ToolchainExecutables to the full path
// i.e `arm-none-eabi-gcc` becomes `{host_absolute_path}/arm-none-eabi-gcc{host_executable_extension}`
{
    ToolchainVerifyConfig verify_config;
    // Modify it here if needed
    arm_gcc.Verify(verify_config);
}

Example for Custom Toolchain

BaseToolchain custom_toolchain(ToolchainId::Custom, "custom_new_toolchain", "assembler", "c_compiler", "cpp_compiler", "archiver", "linker");

// Toolchain::Find similar to previous example

// Find all the relevant toolchains on your host system
// Selects the first found toolchain
// Runs a verification function on the selected toolchain depending on the `ToolchainId`
Toolchain::AddVerificationFunc(ToolchainId::Custom,
[](const ToolchainExecutables & executables) -> buildcc::env::optional<ToolchainCompilerInfo> {
    // Use executables to get compiler_version and target_arch
    if (success) {
        ToolchainCompilerInfo info;
        info.compiler_version = "compiler_version";
        info.target_arch = "target_arch";
        return info;
    } else {
        return {};
    }
}, "custom_verification_func")

ToolchainVerifyConfig verify_config;
verify_config.verification_identifier = "custom_verification_func";
custom_toolchain.Verify(verify_config);

Specialized Toolchain

toolchain_gcc.h

class Toolchain_gcc : public buildcc::Toolchain

Generic GCC Toolchain id = ToolchainId::Gcc

name = “gcc”

asm_compiler = “as”

c_compiler = “gcc”

cpp_compiler = “g++”

archiver = “ar”

linker = “ld”

Public Functions

inline Toolchain_gcc(const std::string &name = "gcc", const env::optional<ToolchainExecutables> &op_executables = {}, const env::optional<ToolchainConfig> &op_config = {})

virtual ~Toolchain_gcc() = default

Toolchain_gcc(const Toolchain_gcc&) = delete

toolchain_mingw.h

class Toolchain_mingw : public buildcc::Toolchain

Generic MinGW Toolchain id = ToolchainId::MinGW

name = “gcc”

asm_compiler = “as”

c_compiler = “gcc”

cpp_compiler = “g++”

archiver = “ar”

linker = “ld”

Public Functions

inline Toolchain_mingw(const std::string &name = "gcc", const env::optional<ToolchainExecutables> &op_executables = {}, const env::optional<ToolchainConfig> &op_config = {})

virtual ~Toolchain_mingw() = default

Toolchain_mingw(const Toolchain_mingw&) = delete

toolchain_msvc.h

class Toolchain_msvc : public buildcc::Toolchain

Generic GCC Toolchain id = ToolchainId::Msvc

name = “msvc”

asm_compiler = “cl”

c_compiler = “cl”

cpp_compiler = “cl”

archiver = “lib”

linker = “link”

Public Functions

inline Toolchain_msvc(const std::string &name = "msvc", const env::optional<ToolchainExecutables> &op_executables = {}, const env::optional<ToolchainConfig> &op_config = {})

virtual ~Toolchain_msvc() = default

Toolchain_msvc(const Toolchain_msvc&) = delete

Example

// Default GCC toolchain
Toolchain_gcc gcc;

// Default MinGW toolchain
Toolchain_mingw mingw;

// Default MSVC toolchain
Toolchain_msvc msvc;