clang-tidy with CMake and an embedded target

Question

The goal here to help people catch some bugs on their embedded systems when developing with C++. As part of this I'm trying to get clang-tidy to work for small embedded targets.

I'm trying setup CMake to do the following:

1. Run clang tidy on build; then
2. Compile with GCC 8.2

However, clang-tidy fails with "unknown target CPU 'armv6-m"

--

The CMake script I've used is as follows:

ClangTidy.cmake

set(ENABLE_CLANG_TIDY ON CACHE BOOL "Add clang-tidy automatically to builds")
if (ENABLE_CLANG_TIDY)
    find_program(CLANG_TIDY_EXE NAMES "C:\\Program Files\\LLVM\\bin\\clang-tidy.exe")
    if (CLANG_TIDY_EXE)
        message(STATUS "clang-tidy found: ${CLANG_TIDY_EXE}")
        set(CLANG_TIDY_CHECKS "-*,modernize-*")
        set(CMAKE_CXX_CLANG_TIDY "${CLANG_TIDY_EXE};-checks=${CLANG_TIDY_CHECKS};-header-filter='${CMAKE_SOURCE_DIR}/*'"
        CACHE STRING "" FORCE)
    else()
        message(AUTHOR_WARNING "clang-tidy not found!")
        set(CMAKE_CXX_CLANG_TIDY "" CACHE STRING "" FORCE) # delete it
    endif()
endif()

armv6-m is part of the CMake script, but it is only used for GCC with the following being used to setup the GCC flags:

set(TARGET STM32F070x6)
set(ARCH armv6-m)
set(CORE cortex-m0)
set(CMAKE_CXX_FLAGS "-march=${ARCH} -mcpu=${CORE} -D${TARGET}")

And then the following to build:

#
# Including extra cmake rules
include(cmake/ClangTidy.cmake)

#Compile and link the exe :)
add_executable(${TARGET}.elf ${MAIN_SOURCE})

#Print the size of the .hex
add_custom_target(size ALL arm-none-eabi-size ${TARGET}.elf DEPENDS ${TARGET}.elf)
add_custom_target(${TARGET}.bin ALL DEPENDS ${TARGET}.elf COMMAND ${CMAKE_OBJCOPY} -Obinary ${TARGET}.elf ${TARGET}.bin)

The resulting build message from cmake build is:

[build] "C:\Program Files\CMake\bin\cmake.exe" -E __run_co_compile 
--tidy="C:/Program Files/LLVM/bin/clang-tidy.exe;-checks=-*,modernize-*;-header-filter='G:/Files/Git/projectname/*'" --source=../src/main.cpp 
-- C:\PROGRA~2\GNUTOO~1\82018-~1\bin\AR10B2~1.EXE  -DHSE_VALUE=48000000 -DSTM32F070x6 -DTRACE -DUSE_STDPERIPH_DRIVER -I../include -I../system -I../library -I../library/usb -I../library/usb/HID -I../library/usb/LL -I../library/usb/Standard -I../library/usb/Types -I../library/common -I../library/common/SCPI -I../library/common/containers -I../library/peripherals -I../library/peripherals/Bitbanging -I../st-library/include -I../st-library/include/arm -I../st-library/include/cmsis -I../st-library/include/cortexm -I../st-library/include/diag -I../st-library/include/stm32f0-stdperiph -march=armv6-m -mcpu=cortex-m0 -DSTM32F070x6 -Os -mthumb -g2 -ggdb -pedantic -Wall -Wextra -Wfloat-equal -Wshadow -Wall -Wl,--gc-sections -fmessage-length=0 -ffunction-sections -fdata-sections -ffreestanding -fno-builtin -std=c++1z -fno-rtti -fno-exceptions -fno-use-cxa-atexit -fno-threadsafe-statics -ftemplate-backtrace-limit=0 -O2 -g -DNDEBUG -MD -MT CMakeFiles/STM32F070x6.elf.dir/src/main.cpp.obj -MF CMakeFiles\STM32F070x6.elf.dir\src\main.cpp.obj.d -o CMakeFiles/STM32F070x6.elf.dir/src/main.cpp.obj -c ../src/main.cpp

Immediately after the above the error occurs:

[build] error: unknown target CPU 'armv6-m' [clang-diagnostic-error]
[build] note: valid target CPU values are: nocona, core2, penryn, bonnell, atom, silvermont, slm, goldmont, goldmont-plus, tremont, nehalem, corei7, westmere, sandybridge, corei7-avx, ivybridge, core-avx-i, haswell, core-avx2, broadwell, skylake, skylake-avx512, skx, cascadelake, cannonlake, icelake-client, icelake-server, knl, knm, k8, athlon64, athlon-fx, opteron, k8-sse3, athlon64-sse3, opteron-sse3, amdfam10, barcelona, btver1, btver2, bdver1, bdver2, bdver3, bdver4, znver1, x86-64

The target ( armv6-m ) field appears to be the same one that GCC used. But I'm not sure why clang-tidy is being called with the target field.

Answer 1

in the source code we can see:

static int HandleTidy(const std::string& runCmd, const std::string& sourceFile,
                      const std::vector<std::string>& orig_cmd)
{
  // Construct the clang-tidy command line by taking what was given
  // and adding our compiler command line.  The clang-tidy tool will
  // automatically skip over the compiler itself and extract the
  // options.
  int ret;
  std::vector<std::string> tidy_cmd = cmExpandedList(runCmd, true);
  tidy_cmd.push_back(sourceFile);
  tidy_cmd.emplace_back("--");
  cmAppend(tidy_cmd, orig_cmd);

src: https://github.com/Kitware/CMake/blob/09032f09f8d2b4f7af658060ef434083f9d6a0d4/Source/cmcmd.cxx#L196-L207

So I would say, all compiler options ie CMAKE_CXX_FLAGS are also passed to clang-tidy by default...

Answer 2

As a workaround you could write a small script which filters the parameters received and then call clang-tidy with the filtered list of parameters. This script can then be handed to CMAKE_CXX_CLANG_TIDY instead of the actual executable.