How to set up CMake to cross compile with clang for ARM embedded on Windows?

Question

I'm trying to generate Ninja makefiles to cross compile a C++ project with Clang for an ARM Cortex A5 CPU. I created a toolchain file for CMake but it seems like there is an error or something missing which I'm unable to find. When invoke CMake with the toolchain file below I get the following error.

CMake command:

cmake -DCMAKE_TOOLCHAIN_FILE="..\Src\Build\Toolchain-clang-arm.cmake" -GNinja ..\Src\

Output:

-- The C compiler identification is Clang 7.0.0 CMake Error at C:/Users/user/scoop/apps/cmake/3.13.4/share/cmake-3.13/Modules/CMakeDetermineCompilerId.cmake:802 (message): The Clang compiler tool

"C:/Program Files/LLVM/bin/clang.exe"

targets the MSVC ABI but has a GNU-like command-line interface. This is not supported. Use 'clang-cl' instead, e.g. by setting 'CC=clang-cl' in the environment. Furthermore, use the MSVC command-line environment. Call Stack (most recent call first):
C:/Users/user/scoop/apps/cmake/3.13.4/share/cmake-3.13/Modules/CMakeDetermineCCompiler.cmake:113 (CMAKE_DIAGNOSE_UNSUPPORTED_CLANG) CMakeLists.txt:2 (PROJECT)

-- Configuring incomplete, errors occurred!

CMake toolchain file (Toolchain-clang-arm.cmake):

set(CMAKE_CROSSCOMPILING TRUE)
SET(CMAKE_SYSTEM_NAME Generic)
set(CMAKE_SYSTEM_PROCESSOR arm)

# Clang target triple
SET(TARGET armv7-none-eabi)

# specify the cross compiler
SET(CMAKE_C_COMPILER_TARGET ${TARGET})
SET(CMAKE_C_COMPILER clang)
SET(CMAKE_CXX_COMPILER_TARGET ${TARGET})
SET(CMAKE_CXX_COMPILER clang++)
SET(CMAKE_ASM_COMPILER_TARGET ${TARGET})
SET(CMAKE_ASM_COMPILER clang)

# C/C++ toolchain
SET(TOOLCHAIN "C:/Program Files (x86)/GNU Tools ARM Embedded/7 2018-q2-update")
SET(CMAKE_C_COMPILER_EXTERNAL_TOOLCHAIN ${TOOLCHAIN})
SET(CMAKE_CXX_COMPILER_EXTERNAL_TOOLCHAIN ${TOOLCHAIN})

# specify compiler flags
SET(ARCH_FLAGS "-target armv7-none-eabi -mcpu=cortex-a5")
SET(CMAKE_C_FLAGS "-Wall -Wextra ${ARCH_FLAGS}" CACHE STRING "Common flags for C compiler")
SET(CMAKE_CXX_FLAGS "-Wall -Wextra -std=c++11 -fno-exceptions -fno-threadsafe-statics ${ARCH_FLAGS}" CACHE STRING "Common flags for C++ compiler")

I used the CMake and Clang documentation and some random link from the net to create the toolchain file. The whole project compiles fine with ARM GCC for Windows, so the toolchain file seems to be the only missing piece of the puzzle.

EDIT

I tried to work around the CMake compiler checks by forcing the compiler. I replace the lines with SET(CMAKE_C_COMPILER clang), SET(CMAKE_CXX_COMPILER clang++) etc. with:

CMAKE_FORCE_C_COMPILER(clang Clang)
CMAKE_FORCE_CXX_COMPILER(clang++ Clang)

The error stays the same.

EDIT

I can successfully compile a hello world example with clang -target arm-none-eabi. So the issue seems to be in CMake. I created a bug in the CMake issue tracker.

Tool versions:

clang version 7.0.0 (tags/RELEASE_700/final)
cmake version 3.13.4

You left a comment on the CMake GitLab issue that indicates you may have been successful using msys2 with the clang package. If so, would you kindly post an answer/comment here with details on how you got it to work? I am still having no success, and I believe I am trying to do essentially the same thing. — AngCaruso
@AngCaruso Thanks for the reminder to write an answer. I hope this answers your question. — S. Marti

S. Marti S. Marti · Accepted Answer · 2019-04-10T10:35:06

My question was answered through the reply to my bug report, but I add the answer here to have all information in one place for future reference.

In short: CMake currently does not support to use the clang/clang++ command line interface if you install Clang from llvm.org. If you want to use the clang/clang++ interface (which is necessary to cross-compile for ARM) you have to install Clang via msys2.

In detail

Clang on Windows has two different command line interfaces:

clang/clang++ the default interface that attempts to be compatible with GCCs gcc/g++ and targets the GNU ABI
clang-cl that attempts to be compatible with Microsofts Visual C++ compiler cl.exe and targets the MSVC ABI

In order to cross-compile for ARM you need the clang/clang++ interface. The Problem is CMake supports different interfaces depending on how you installed Clang (see the bug in the CMake issue tracker for more details):

If you install Clang from llvm.org CMake only supports the clang-cl interface.
If you install Clang via msys2 CMake supports the clang/clang++ interface.

So here is what I did:

Install msys2
Install Clang and CMake with pacman. There are two clang packages in msys2, a mingw32 and a mingw64 version. I used the mingw64 package (mingw-w64-x86_64-clang).
Launch the mingw64 shell and run CMake and build from there.

Toolchain file

There were two problems with my original toolchain file that took my a long time to fix. So I hope this will save others some time:

The target triple (e.g. arm-none-eabi) needs to match the prefix of the GCC binutils exactly. The prefix of my binutils was arm-none-eabi (e.g. arm-none-eabi-ar) so I had to change the target triple accordingly.
CMAKE_TRY_COMPILE_TARGET_TYPE needs to be changed to STATIC_LIBRARY in order to prevent CMake from running the linker during the compile check.

Here is the final toolchain file I used (you can also find a good example for a toolchain file in this GitHub repo):

cmake_minimum_required(VERSION 3.13)

set(CMAKE_SYSTEM_NAME Generic)
set(CMAKE_SYSTEM_PROCESSOR ARM)

if(DEFINED ENV{GCC_ARM_TOOLCHAIN})
    set(GCC_ARM_TOOLCHAIN $ENV{GCC_ARM_TOOLCHAIN})
else()
    set(GCC_ARM_TOOLCHAIN "C:/Users/user/tools/gcc-arm-none-eabi-7-2018-q2-update-win32")
endif()

LIST(APPEND CMAKE_PROGRAM_PATH ${GCC_ARM_TOOLCHAIN})

# Specify the cross compiler
# The target triple needs to match the prefix of the binutils exactly
# (e.g. CMake looks for arm-none-eabi-ar)
set(CLANG_TARGET_TRIPLE arm-none-eabi)
set(GCC_ARM_TOOLCHAIN_PREFIX ${CLANG_CLANG_TARGET_TRIPLE})
set(CMAKE_C_COMPILER clang)
set(CMAKE_C_COMPILER_TARGET ${CLANG_TARGET_TRIPLE})
set(CMAKE_CXX_COMPILER clang++)
set(CMAKE_CXX_COMPILER_TARGET ${CLANG_TARGET_TRIPLE})
set(CMAKE_ASM_COMPILER clang)
set(CMAKE_ASM_COMPILER_TARGET ${CLANG_TARGET_TRIPLE})

# Don't run the linker on compiler check
set(CMAKE_TRY_COMPILE_TARGET_TYPE STATIC_LIBRARY)

# Specify compiler flags
set(ARCH_FLAGS "-mcpu=cortex-a5 -mthumb -mfpu=neon-vfpv4 -mfloat-abi=hard -mno-unaligned-access")
set(CMAKE_C_FLAGS "-Wall ${ARCH_FLAGS}" CACHE STRING "Common flags for C compiler")
set(CMAKE_CXX_FLAGS "-Wall -std=c++17 -fno-exceptions -fno-rtti -fno-threadsafe-statics ${ARCH_FLAGS}" CACHE STRING "Common flags for C++ compiler")
set(CMAKE_ASM_FLAGS "-Wall ${ARCH_FLAGS} -x assembler-with-cpp" CACHE STRING "Common flags for assembler")
set(CMAKE_EXE_LINKER_FLAGS "-nostartfiles -Wl,-Map,kernel.map,--gc-sections -fuse-linker-plugin -Wl,--use-blx --specs=nano.specs --specs=nosys.specs" CACHE STRING "")

# C/C++ toolchain
set(GCC_ARM_SYSROOT "${GCC_ARM_TOOLCHAIN}/${GCC_ARM_TOOLCHAIN_PREFIX}")
# set(CMAKE_SYSROOT ${GCC_ARM_SYSROOT})
set(CMAKE_FIND_ROOT_PATH ${GCC_ARM_SYSROOT})

# Search for programs in the build host directories
set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER)
# For libraries and headers in the target directories
set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY)
set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY)

How to set up CMake to cross compile with clang for ARM embedded on Windows?

2 Answers