Jak wykryć docelową architekturę za pomocą CMake?

Mam rozwiązanie dla Przypadku, Gdy Host i system docelowy są takie same.

Najpierw musisz wywołać "uname-m", aby uzyskać " Nazwa sprzętu maszynowego ". Następnie musisz odciąć końcowy " carriage Return", aby uzyskać rzeczywistą wartość z powrotem do podanej zmiennej.

EXECUTE_PROCESS( COMMAND uname -m COMMAND tr -d '\n' OUTPUT_VARIABLE ARCHITECTURE )

Teraz możesz wydrukować zmienną ${Architektura}:

message( STATUS "Architecture: ${ARCHITECTURE}" )

Albo zrobić jakąś kanonizację do mapowania, np. "x86_64", "amd64",... do np. "64Bit". To samo dotyczy 32Bit. Z tym możesz wykonać kompilację archtecture dependend jak:

if( ${ARCHITECTURE} STREQUAL "64Bit" )
    set( BLA_LIBRARY "/opt/lib/libBla.so" )
else()
    set( BLA_LIBRARY "/opt/lib32/libBla.so" )
endif()

Android ${ANDROID_ABI}

Zmienna ${ANDROID_ABI} jest sposobem na Androida, gdzie przyjmuje wartości takie jak arm64-v8a, x86_64 i tak dalej.

Jest używany na oficjalnym przykładzie biblioteki NDK: https://github.com/googlesamples/android-ndk/blob/840858984e1bb8a7fab37c1b7c571efbe7d6eb75/hello-libs/app/src/main/cpp/CMakeLists.txt#L25

Skomentowałem ten przykład pod adresem: NDK: jak włączyć wstępnie zbudowaną bibliotekę współdzieloną niezależnie od architektury

Jeśli twój proces budowania obejmował więcej niż 1 Cel, lepiej niech CMake wie na czym opiera się ARCH/toolchain. Możesz postępować zgodnie z instrukcją dla kompilacji krzyżowej CMake, która zachęca do utworzenia pliku Toolchain CMake, który pozwala wybrać używany zestaw narzędzi/kompilator.

Stworzyłem jedną do budowania mojej aplikacji C++ Linux dla procesora arm i nazwałem ją toolchain-arm.cmake.

Obejmuje set(CMAKE_SYSTEM_PROCESSOR arm).

I wtedy wykonanie CMake tak:

cmake -DCMAKE_BUILD_TYPE=Release -DCMAKE_TOOLCHAIN_FILE={my toolchain cmake path}/toolchain-arm.cmake {my source path}

W ramach CMakeList mojego projektu.txt mogę odwoływać się do CMAKE_SYSTEM_PROCESSOR w dowolny sposób.

Podczas budowania dla X86, nie podaję odniesienia do-DCMAKE_TOOLCHAIN_FILE, pozostawiając cmake_system_processor niezdefiniowany, lub przynajmniej nie zdefiniowany jako arm.

SET(CMAKE_SYSTEM_NAME Linux)
SET(CMAKE_SYSTEM_VERSION 1)
set(CMAKE_SYSTEM_PROCESSOR arm)

# specify the cross compiler
SET(ENV{TOOLCHAIN_ROOT} /home/user/toolchain/tools-master/arm-bcm2708/gcc-linaro-arm-linux-gnueabihf-raspbian/bin )
SET(CMAKE_C_COMPILER   $ENV{TOOLCHAIN_ROOT}/arm-linux-gnueabihf-gcc)
SET(CMAKE_CXX_COMPILER $ENV{TOOLCHAIN_ROOT}/arm-linux-gnueabihf-gcc)

# 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)

Ten post jest stary, więc przepraszam, jeśli wskrzeszenie zmarłych tutaj, ale pomyślałem, że podzielę się rozwiązaniem, które zrobiłem.

Nie chciałem używać żadnej zewnętrznej aplikacji i niestety toolchain.plik cmake, którego używamy nie ma ustawionego łuku w innej zmiennej, więc wykrywam go patrząc na zmienne CMAKE_C_FLAGS i CMAKE_CXX_FLAGS szukając argumentu -march do GCC. Jeśli go nie ma, wraca do CMAKE_HOST_SYSTEM_PROCESSOR.

Szybkie spojrzenie na dokumentację Clang wydaje się wskazywać, że to to nie zadziała, ale wystarczy drugi krok regex, aby dopasować oczekiwany argument.

set(TARGET_ARCH_REGEX "^.*-march[= ]([^ ]+).*$")
string(REGEX MATCH "${TARGET_ARCH_REGEX}" TARGET_ARCH_MATCH ${CMAKE_C_FLAGS} ${CMAKE_CXX_FLAGS})
if (TARGET_ARCH_MATCH)
    string(REGEX REPLACE "${TARGET_ARCH_REGEX}" "\\1" TARGET_ARCH ${CMAKE_C_FLAGS} ${CMAKE_CXX_FLAGS})
else()
    set(TARGET_ARCH ${CMAKE_HOST_SYSTEM_PROCESSOR})
endif()

Na razie nie potrzebujesz żadnych hacków do określenia docelowej architektury: zmienna OSX_ARCHITECTURES została dodana do cmake i może być używana do tego celu: http://public.kitware.com/Bug/view.php?id=8725

Myślę, że najprostszym i najbardziej niezawodnym rozwiązaniem jest ręczne określenie architektury dla platformy, na której budujesz (możesz użyć cmake . -DMY_ARCHITECTURE=x86 lub czegoś podobnego). Przynajmniej to robimy w naszych projektach, z powodu tych samych problemów, które opisałeś powyżej

Jest to dobrze przetestowany sposób poznania architektury hosta:

# Store in CMAKE_DEB_HOST_ARCH var the current build architecture
execute_process(COMMAND
  dpkg-architecture
    -qDEB_HOST_ARCH
  OUTPUT_VARIABLE
    CMAKE_DEB_HOST_ARCH
  OUTPUT_STRIP_TRAILING_WHITESPACE
)

I użyj tych informacji później w CMakeLists, jak potrzebujesz

if(${CMAKE_DEB_HOST_ARCH} MATCHES "armhf")
  ...
elseif(${CMAKE_DEB_HOST_ARCH} MATCHES "i386")
  ...
else()
  ...
endif()