Erkennen Sie 32-Bit-x86-Prozessor in CMakeList.txt?

Question

Wir fangen errors in our CMake makefiles wegen Mangel an -fPIC. Sie ist eine von einer CI20 MIPS Entwickler-Board:

... 
[ 92%] Built target cryptopp-object 
Scanning dependencies of target cryptopp-shared 
Scanning dependencies of target cryptopp-static 
Linking CXX static library libcryptopp.a 
Linking CXX shared library libcryptopp.so 
/usr/bin/ld: CMakeFiles/cryptopp-object.dir/cryptlib.cpp.o: relocation R_MIPS_HI16 against 
`a local symbol' can not be used when making a shared object; recompile with -fPIC 
CMakeFiles/cryptopp-object.dir/cryptlib.cpp.o: could not read symbols: Bad value 
collect2: ld returned 1 exit status 

Die Politik des Projektes ist für uns PIC überall, außer 32-Bit-x86 aufgrund Drücken registrieren. Das bedeutet x86_64, ARM-32, Aarch32, Aarch64, MIPS, MIPS64, UltraSparc usw. erhalten PIC.

Ich glaube, dass der Zielprozessor in CMAKE_SYSTEM_PROCESSOR zur Verfügung gestellt wird. Das Problem, das ich habe, ist, dass die Docs mir die Werte nicht sagen, also kann ich nicht herausfinden, wie man einen "nicht 32-Bit x86" -Test erstellt.

Wie kann ich 32-Bit-x86-Prozessor in CMakeList.txt erkennen?

Noch besser, ich würde gerne eine umfassende Liste von Prozessoren sehen, die CMake CMAKE_SYSTEM_PROCESSOR setzt. Wenn jemand die Liste hat, wäre es großartig, sie zur Verfügung zu stellen.

Answer 1

Ich würde wahrscheinlich etwas um den Compiler herum bauen.

Eine enge Annäherung vorhandenen Variablen/modules wäre:

include(TestBigEndian) 

if (NOT WIN32) 
    TEST_BIG_ENDIAN(_bigendian) 
    if((CMAKE_SIZEOF_VOID_P GREATER 4) OR (_bigendian)) 
     message(
      STATUS "Setting ${CMAKE_CXX_COMPILE_OPTIONS_PIC} " 
        "for machine ${CMAKE_HOST_SYSTEM_PROCESSOR}" 
     ) 
     set(CMAKE_POSITION_INDEPENDENT_CODE 1) 
    endif() 
endif() 

Kurz gesagt, was ich getan habe:

• WIN32 für 64-Bit-Windows-Compiler/Umgebungen gilt auch
• CMAKE_SIZEOF_VOID_P GREATER 4 prüft auf "größer als 32 Bit"
• Die letzte ist die größte Annahme: nimm alle kleinen Endian-Prozessoren wie Intel/AMD-basierten
• CMAKE_POSITION_INDEPENDENT_CODE allgemeineren Gebrauchte -fPIC

ich eine genauere Methode wäre, zugeben zu setzen etwas um eine vordefinierte Makros Test zu bauen.

Edit: Hinzugefügt "Vordefinierte Makros prüfen" Alternative

Hier ist die genauere Prüfung für vordefinierte Makros:

include(CheckCXXSourceCompiles) 

if (CMAKE_CXX_COMPILE_OPTIONS_PIC) 
    set(
     _preDefMacrosX86 
      __i386 __i386__ __i486__ __i586__ __i686__  
      _M_I86 _M_IX86 __X86__ _X86_ __THW_INTEL__ 
      __I86__ __INTEL__ __386 
    ) 
    set(_code "void main() {}") 
    foreach(_macro IN LISTS _preDefMacrosX86) 
     set(
      _code 
      "${_code}\n\#ifdef ${_macro}\n\#error ${_macro} is defined\n\#endif" 
     ) 
    endforeach() 
    CHECK_CXX_SOURCE_COMPILES("${_code}" _canCompileX86DoesFailCheck) 

    if((CMAKE_SIZEOF_VOID_P GREATER 4) OR (_canCompileX86DoesFailCheck)) 
     message(STATUS "Setting ${CMAKE_CXX_COMPILE_OPTIONS_PIC}") 
     set(CMAKE_POSITION_INDEPENDENT_CODE 1) 
    endif() 
endif() 

Referenzen

• How to detect if 64 bit MSVC with cmake?
• Detecting CPU architecture compile-time

Answer 2

Ich glaube, das führt die Erkennung auf fast alles außer Windows. Windows verbraucht -fPIC nicht, also spielt es für mich keine Rolle. Die Teile wurden aus drei Stack Overflow Antworten zusammengeklebt.

# Stop hiding the damn output... 
set(CMAKE_VERBOSE_MAKEFILE on) 

# Enable PIC for all targets except Windows and 32-bit x86 
if (NOT (WINDOWS OR WINDOWS_STORE OR WINDOWS_PHONE)) 

    set (UNAME_CMD "uname") 
    set (UNAME_ARG "-m") 
    execute_process(COMMAND ${UNAME_CMD} ${UNAME_ARG} 
     WORKING_DIRECTORY ${PROJECT_SOURCE_DIR} 
     RESULT_VARIABLE UNAME_RESULT 
     OUTPUT_VARIABLE UNAME_MACHINE) 

    # Use Regex; match i386, i486, i586 and i686 
    IF (NOT (${UNAME_MACHINE} MATCHES "i.86")) 
     # message(STATUS "Setting -fPIC for machine ${UNAME_MACHINE}") 
     if (CMAKE_VERSION VERSION_LESS 2.8.12) 
      add_definitions(-fPIC) 
     else() 
      add_compile_options(-fPIC) 
     endif() 
    endif() 
endif() 

---

Sie erhalten die Maschine mit uname -m, und seine meist richtig, auch auf OS X. Zum Beispiel auf OS X, uname -p kehrt i386 während uname -m kehrt x86_64. Ich erinnere mich, dass 10.6 oder 10.7 etwas flockig war, als der Übergang zu 64-Bit-Macs gemacht wurde.

Sie bekommen den Prozessor mit uname -p manchmal, aber es schlägt auf vielen Dev-Boards fehl. Zum Beispiel gibt mein ci20 dev-board "Mips" für die Maschine und "unbekannt" für den Prozessor zurück. Ein anderes Beispiel ist mein LeMaker HiKey. Es gibt "aarch64" für die Maschine und "unknown" für den Prozessor zurück.

---

Ich würde immer noch gerne die Liste der Prozessoren von Cmake zur Verfügung gestellt sehen.