Offer the capability, through variable `CMAKE_LINKER_TYPE`, as well as
the target property `LINKER_TYPE` to specify which linker must be used.
The implementation of this capability is specified by variables specific
to the language and linker type: `CMAKE_<LANG>_USING_LINKER_<TYPE>`.
Some definitions are provided as part of `CMake`.
For example, to select the `LLVM` linker rather than the standard one,
the type `LLD` should be specified through the variable `CMAKE_LINKER_TYPE`.
And, on `Apple`, `Linux` and some environments on `Windows`, the variable
`CMAKE_<LANG>_USING_LINKER_LLD` has value `-fuse-ld=lld`. And for `Windows`
environments based on `MSVC`, where the linker is used directly, the tool
`lld-link.exe` will be used rather than `link.exe`.
Fixes: #19174, #24254, #24990
`include-what-you-use` diagnostics, in practice, are specific to
the environment's compiler and standard library. Update includes
to satisfy IWYU for our CI job under Debian 12.
Use gbuild project syntax for setting the language type for the file.
gbuild will pick the correct compiler or tool to use.
NOTE: Language names come from gbuild config files. Therefore to
compile a file with the C++ compiler use "C++" not "CXX".
The previous implementation was passing the C compiler a flag to compile as C++
if LANGUAGE was set to "CXX".
The top level project and the target projects are all in the same
directory so they are easier to find and looks nicer in the GUI.
All of the ancillary project files are located in the target
subdirectory.
On Linux run build events scripts as "/bin/sh script.sh".
Prefer using _WIN32 over variable for host platform decisions.
-- This is consistant with other parts of CMake.
Most calls to `MaybeConvertToRelativePath` use one of our common work
directories (e.g. top of the build tree) as the local path. Add helpers
for each of the common cases to simplify and clarify call sites.
Since commit 777ceaea94 (cmMakefile: Delay custom command creation,
2019-10-17, v3.17.0-rc1~352^2) we process custom command declarations at
generate time. Therefore we do not need to look up what source file
holds the custom command producing a given output until generate time.
4318e8ed35 gitlab-ci: add iwyu job
0866b9253b gitlab-ci: add initial clang-tidy build
0a5bcf97b9 gitlab-ci: add scripts for use by CI
960158b90d ci: add scripts to download build tools
6af91c7c4d ci: add an image for Debian 10
68903ae238 ci: add a Docker container for building CMake
3ac24a8a6e cmFunctionBlocker: include missing header
b745b8fd36 IWYU: mark includes needed for assert statements as needed
...
Acked-by: Kitware Robot <kwrobot@kitware.com>
Merge-request: !4643
The `std::endl` manipulator, except inserting `\n` character, also
performs `os.flush()`, which may lead to undesired effects (like
disk I/O in the middle of forming data strings). For the
`std::stringstream` it also has no meaning.
* replace multiple `operator<<` calls on a string literal w/
the only call and the only (bigger) string literal;
* replace one character string literal used in `operator<<`
w/ a char literal.
cbbca9ee2a Convert more loops to range-based for-loops
9296cd0551 GHS: Name range-based for-loop variable types explicitly
db17de2438 GHS: Use cm::erase in place of loop
Acked-by: Kitware Robot <kwrobot@kitware.com>
Merge-request: !4446
Set the MinTypeNameLength option to an impossibly high value in order
to limit the diagnostics to iterators. Leave new expressions and cast
expressions for later.
This patch is generated by a python script that uses regular expressions to
search for string concatenation patterns of the kind
```
std::string str = <ARG0>;
str += <ARG1>;
str += <ARG2>;
...
```
and replaces them with a single `cmStrCat` call
```
std::string str = cmStrCat(<ARG0>, <ARG1>, <ARG2>, ...);
```
If any `<ARGX>` is itself a concatenated string of the kind
```
a + b + c + ...;
```
then `<ARGX>` is split into multiple arguments for the `cmStrCat` call.
If there's a sequence of literals in the `<ARGX>`, then all literals in the
sequence are concatenated and merged into a single literal argument for
the `cmStrCat` call.
Single character strings are converted to single char arguments for
the `cmStrCat` call.
`std::to_string(...)` wrappings are removed from `cmStrCat` arguments,
because it supports numeric types as well as string types.
`arg.substr(x)` arguments to `cmStrCat` are replaced with
`cm::string_view(arg).substr(x)`
This replaces invocations of
- `cmSystemTools::IsInternallyOn` with `cmIsInternallyOn`
- `cmSystemTools::IsNOTFOUND` with `cmIsNOTFOUND`
- `cmSystemTools::IsOn` with `cmIsOn`
- `cmSystemTools::IsOff` with `cmIsOff`
Enables the clang-tidy test performance-inefficient-string-concatenation
and replaces all inefficient string concatenations with `cmStrCat`.
Closes: #19555
An old workaround for `std::allocator_traits<>::value_type` lints from
IWYU on `std::vector<>` usage breaks IWYU's handling of `<memory>`.
Convert the workaround to use the same approach we already use for a
workaround of `std::__decay_and_strip<>::::__type` lints. Then update
the `<memory>` inclusions to follow the now-correct IWYU lints.
-- Do not use reference projects, use build hierarchy instead.
gbuild has three parallel levels:
* low -- Parallelizes compiling source files within a single project (.gpj)
file when safe to do so.
* medium -- Parallelizes processing files within a single linked output when
safe to do so.
* high [default] -- Parallelizes processing files whenever safe to do so,
including linking task.
Testing showed that for some combinations of gbuild / MULTI there are issues
with building a project that uses references to target project files along with
using {nobuild} option.
Sometimes the archiving of a library and linking of an executable were
happening in parallel and the build would fail when linking because the
archive wasn't complete.
This behavior was also inconsistent when running the build from MULTI and
from the command line with gbuild. In some cases MULTI did not parallelize
archiving and linking, but gbuild performed these actions in parallel.
The parallel build issue was not seen when using a build hierarchy where the
project listed the project files normally instead of using a reference link.
The other option was to add the -parallel_level=medium to the command line
when using "cmake --build" but this wouldn't fix the issue if gbuild itself
was used to and the user might not be aware of the extra option used by cmake.
-- Restructure projects and files to support proper building of targets
Build order is determined by hierarchy of project files and folders
Custom targets may have been run multiple times in the original file / folder structure
-- Default to build targets that are part of ALL target
-- List all known targets for this project
Includes global targets for ALL_BUILD and INSTALL
-- Compute build order for building targets
-- add new file type to run a shell script
-- gbuild does not compute interfile dependencies like other build tools.
Therefore calculate the required build order of custom commands and
list all of them in the CMake Rules subproject.
-- Fixes issue where commands run out of order; Run commands as single script
Do not allow build events to run in parallel
-- Use command generator to parse the commands
-- Support pre-link build events
-- Support more options: COMMENT, BYPRODUCTS, WORKING_DIRECTORY
