GCC

Lowlevel GCC Tests

Simple

Compile a single source

// GCC specialized toolchain
Toolchain_gcc toolchain;

// GCC specialized targets
// Create "Simple" target (meant to use the GCC compiler)
// On Windows the equivalent is the MinGW compiler
ExecutableTarget_gcc target("Simple", gcc, "");
target.AddSource("main.cpp");
target.Build();

// Build
tf::Executor executor;
executor.run(target.GetTaskflow());
executor.wait_for_all();

IncludeDir

Compile multiple sources with header files

// GCC specialized toolchain
Toolchain_gcc toolchain;

// GCC specialized targets
// Create "IncludeDir" target (meant to use the GCC compiler)
// On Windows the equivalent is the MinGW compiler
ExecutableTarget_gcc target("IncludeDir", gcc, "files");
target.AddSource("main.cpp", "src");
target.AddSource("src/random.cpp");

// Track header for rebuilds
target.AddHeader("include/random.h");

// Add include dir to search paths
target.AddIncludeDir("include");
target.Build();

// Build
tf::Executor executor;
executor.run(target.GetTaskflow());
executor.wait_for_all();

StaticLib

Compile a static library which is used by an executable

// GCC specialized toolchain
Toolchain_gcc toolchain;

// GCC specialized targets
// Create "librandom.a" target (meant to use the GCC compiler)
// On Windows the equivalent is the MinGW compiler
StaticTarget_gcc statictarget("librandom", gcc, "files");
statictarget.AddSource("src/random.cpp");
statictarget.AddHeader("include/random.h");
statictarget.AddIncludeDir("include");
statictarget.Build();

// GCC specialized targets
// Create "statictest" target (meant to use the GCC compiler)
// On Windows the equivalent is the MinGW compiler
ExecutableTarget_gcc exetarget("statictest", gcc, "files");
exetarget.AddSource("main.cpp", "src");
exetarget.AddIncludeDir("include");
exetarget.AddLibDep(statictarget);
exetarget.Build();

// Build
tf::Executor executor;
tf::Taskflow taskflow;

// Explicitly setup your dependencies
tf::Task statictargetTask = taskflow.composed_of(statictarget.GetTaskflow());
tf::Task exetargetTask = taskflow.composed_of(exetarget.GetTaskflow());
exetargetTask.succeed(statictargetTask);

// Run
executor.run(taskflow);
executor.wait_for_all();

DynamicLib

Compile a dynamic library which is used by an executable

// GCC specialized toolchain
Toolchain_gcc toolchain;

// GCC specialized targets
// Create "librandom.so" target (meant to use the GCC compiler)
// On Windows the equivalent is the MinGW compiler
DynamicTarget_gcc dynamictarget("librandom", gcc, "files");
dynamictarget.AddSource("src/random.cpp");
dynamictarget.AddHeader("include/random.h");
dynamictarget.AddIncludeDir("include");
dynamictarget.Build();

// GCC specialized targets
// Create "dynamictest" target (meant to use the GCC compiler)
// On Windows the equivalent is the MinGW compiler
ExecutableTarget_gcc target("dynamictest", gcc, "files");
target.AddSource("main.cpp", "src");
target.AddIncludeDir("include");
target.AddLibDep(dynamictarget);
target.Build();

// Build
tf::Executor executor;
tf::Taskflow taskflow;

// Explicitly setup your dependencies
auto dynamictargetTask = taskflow.composed_of(dynamictarget.GetTaskflow());
auto targetTask = taskflow.composed_of(target.GetTaskflow());
targetTask.succeed(dynamictargetTask);

executor.run(taskflow);
executor.wait_for_all();

// Post Build step
if (target.IsBuilt()) {
    fs::path copy_to_path =
        target.GetTargetBuildDir() / dynamictarget.GetTargetPath().filename();
    fs::copy(dynamictarget.GetTargetPath(), copy_to_path);
}

Note

Our ExecutableTarget_gcc depends on DynamicTarget_gcc and requires the librandom.so file to be present in the same folder location as the executable when running.

Flags

Using PreprocessorFlags, C Compile flags, Cpp Compile flags and Link flags

// GCC specialized toolchain
Toolchain_gcc toolchain;

// GCC specialized targets
// Create "CppFlags" target (meant to use the GCC compiler)
// On Windows the equivalent is the MinGW compiler
ExecutableTarget_gcc cpptarget("CppFlags", gcc, "files");
cpptarget.AddSource("main.cpp", "src");
cpptarget.AddSource("src/random.cpp");
cpptarget.AddHeader("include/random.h");
cpptarget.AddIncludeDir("include");
cpptarget.AddPreprocessorFlag("-DRANDOM=1");
cpptarget.AddCppCompileFlag("-Wall");
cpptarget.AddCppCompileFlag("-Werror");
cpptarget.AddLinkFlag("-lm");
cpptarget.Build();

// Gcc specialized targets
// Create "CFlags" target (meant to use the GCC compiler)
// On Windows the equivalent is the MinGW compiler
ExecutableTarget_gcc ctarget("CFlags", gcc, "files");
ctarget.AddSource("main.c", "src");
ctarget.AddPreprocessorFlag("-DRANDOM=1");
ctarget.AddCCompileFlag("-Wall");
ctarget.AddCCompileFlag("-Werror");
ctarget.AddLinkFlag("-lm");
ctarget.Build();

// Build
tf::Executor executor;
tf::Taskflow taskflow;

// There isn't any dependency between the 2 targets
taskflow.composed_of(cpptarget.GetTaskflow());
taskflow.composed_of(ctarget.GetTaskflow());

executor.run(taskflow);
executor.wait_for_all();

AfterInstall

Use BuildCC with CMake

• Install BuildCC via CMake to your system and add it to PATH

• Use the script below to compile your build script to an executable

• Copy the Flags build example

• Run the executable from your project root directory

# Package dependencies
# fmt is imported by spdlog by default
find_package(fmt_package NAMES "fmt" REQUIRED)
find_package(spdlog_package NAMES "spdlog" REQUIRED)
find_package(nlohmann_json_package NAMES "nlohmann_json" REQUIRED)
find_package(taskflow_package NAMES "Taskflow" "taskflow" REQUIRED)
find_package(CLI11_package NAMES "CLI11" REQUIRED)
find_package(tiny_process_library_package NAMES "tiny-process-library" REQUIRED)

find_package(buildcc_package NAMES "buildcc" REQUIRED)

message("Find package: ${fmt_package_DIR}")
message("Find package: ${spdlog_package_DIR}")
message("Find package: ${nlohmann_json_package_DIR}")
message("Find package: ${taskflow_package_DIR}")
message("Find package: ${CLI11_package_DIR}")
message("Find package: ${tiny_process_library_package_DIR}") #

message("Find package: ${buildcc_package_DIR}")

# build executable
add_executable(build build.cpp)
target_include_directories(build PRIVATE ${CMAKE_CURRENT_BINARY_DIR}/generated)
target_link_libraries(build PRIVATE
    buildcc
)
if (${MINGW})
    message(WARNING "-Wl,--allow-multiple-definition for MINGW")
    target_link_options(build PRIVATE -Wl,--allow-multiple-definition)
endif()

# Add your constants file for the environment
configure_file(constants.h.in ${CMAKE_BINARY_DIR}/generated/constants.h @ONLY)

Plugins

Demonstrating BuildCC supported plugin usage

• From the Flags example above

• Add the targets for which you would like to generate the Clang CompileCommands Database

plugin::ClangCompileCommands({&cppflags, &cflags}).Generate();

PrecompileHeader

TODO