ITK/Cross Compiling: Difference between revisions

From KitwarePublic
< ITK
Jump to navigationJump to search
(Created page with "This page describes the procedure to follow when cross compiling for another system. In this page, we will refer to the system as: * Target System: The system where the executa...")
 
(Add the historical label after Change-Id Ic1ef99376d11722b1df5a86fb984ae9565d6dbe9 was merged)
 
(39 intermediate revisions by 4 users not shown)
Line 1: Line 1:
This page describes the procedure to follow when cross compiling for another system.
{{ Historical }}
 
__TOC__
 
This page describes the procedure to follow when cross compiling ITK for another system.


In this page, we will refer to the system as:
In this page, we will refer to the system as:
Line 6: Line 10:
* Build System: The system where the executables are built.
* Build System: The system where the executables are built.


= In Linux for Mac =
= In Linux Host for Mac Target =


In this particular case we illustrate
In this particular case we illustrate
Line 16: Line 20:


# Build your tool chain in the build system
# Build your tool chain in the build system
#* This is a compilation sytt
#* This is the set of compiler and linker that must be build in the '''build''' system, but will know how to generate code for the Target system.
# Create a TryRun ... file in the '''native''' system
# Create a TryRun ... file in the '''native''' system
#* This could be generated (as a skeleton) with the following commands
=== Building the ToolChain for Darwin ===
The following is a script developed by Johannes Schindelin (originally intended for [http://pacific.mpi-cbg.de/wiki/index.php/Fiji FIJI])
[[Media:Build-macosx-cross-compiler.sh.gz|Script for Building the Darwing Toolchain in Linux]]
=== Gathering Configuration settings in the target system ===
Following the advice of the CMake Wiki [http://www.cmake.org/Wiki/CMake_Cross_Compiling]
Put the following in a file called ToolChain.cmake
  # this one is important
  SET(CMAKE_SYSTEM_NAME Linux)
  #this one not so much
  SET(CMAKE_SYSTEM_VERSION 1)
  # specify the cross compiler
  SET(CMAKE_C_COMPILER  /usr/bin/gcc)
  SET(CMAKE_CXX_COMPILER /usr/bin/g++)
  # where is the target environment
  SET(CMAKE_FIND_ROOT_PATH  /usr)
  # 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)
and run it with CMake using the command (in an empty directory)
  cmake -DCMAKE_TOOLCHAIN_FILE=./ToolChain.cmake  ~/src/ITK
This will generate (among many other things) a File called
              TryRunResults.cmake
Then, manually populate, the values of each one of the fields.
The values to be put in this file can be taken from the CMakeCache.txt file of a native build in Darwin.
Finally, copy this file to the build system.
=== Using the Configuration in the Host ===
Now that you have copied the TryRunResuls.cmake file to the host system, you can use it as an initial cache for configuring the build.
Do the command in the build system.
    cmake -C ~/TryRunResults.cmake  ~/src/ITK
once the configuration is completed you can proceed to build ITK by simply typing
    make
== The full process scripted ==
The process as a whole has been scripted in the file below
[[Media:ITK-cross-compiling-for-macosx.sh.gz|Script for configuring a cross-compilation build]]
Thanks to Johannes Schindelin for contributing the script.
= In Linux Host for Windows Target =
In this particular case we illustrate
* Target System = Windows
* Build System = Linux
''Note:'' the [http://mxe.cc/ MXE] project has an ITK package! Just
  cd mxe
  make itk
== Major steps ==
# Build your tool chain in the build system
#* This is the set of compiler and linker that must be build in the '''build''' system, but will know how to generate code for the Target system.
#* In this case we use MinGW as the tool chain
# Create a TryRun ... file in the '''native''' system
#* This could be generated (as a skeleton) with the following commands
=== Building the ToolChain for Windows ===
The [http://mxe.cc/ MXE] project will build the toolchain nicely, and it even creates a CMake toolchain file.
The following is a script developed by Johannes Schindelin (originally intended for [http://pacific.mpi-cbg.de/wiki/index.php/Fiji FIJI]).
[[Media:Build-windows-cross-compiler.sh.gz‎|Script for Building the Windows (MinGW) Toolchain in Linux]]
=== Gathering Configuration settings in the target system ===
Following the advice of the CMake Wiki [http://www.cmake.org/Wiki/CMake_Cross_Compiling], put the following in a file called ToolChain.cmake
  # this one is important
  SET(CMAKE_SYSTEM_NAME Linux)
  #this one not so much
  SET(CMAKE_SYSTEM_VERSION 1)
  # specify the cross compiler
  SET(CMAKE_C_COMPILER  /usr/bin/gcc)
  SET(CMAKE_CXX_COMPILER /usr/bin/g++)
  # where is the target environment
  SET(CMAKE_FIND_ROOT_PATH  /usr)
  # 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)
Note that if you are using MXE, it already comes with a toolchain file at
  mxe/usr/i686-pc-mingw32/share/cmake/mxe-conf.cmake
Run CMake using the command (in an empty directory)
  cmake -DCMAKE_TOOLCHAIN_FILE=./ToolChain.cmake  ~/src/ITK
This will generate (among many other things) a File called
              TryRunResults.cmake
The values to be put in this file can be taken from the CMakeCache.txt file of a native build in Windows.  The CMakeCache.txt can be created by manually running a CMake configuration on Windows.  Use [https://gist.github.com/thewtex/5931775 this script] to populate the TryRun results with the Windows CMakeCache.txt contents.
=== Using the Configuration in the Host ===
Now that you have copied the TryRunResuls.cmake file to the host system, you can use it as an initial cache for configuring the build.
Do the command in the build system.
    cmake -C ~/TryRunResults.cmake  ~/src/ITK
once the configuration is completed you can proceed to build ITK by simply typing
    make
The build process will fail when trying to create the HDF5 library.
  [ 73%] Building C object Modules/ThirdParty/HDF5/src/itkhdf5/src/CMakeFiles/H5make_libsettings.dir/H5make_libsettings.c.obj
  Linking C executable ../../../../../../bin/H5make_libsettings.exe
  [ 73%] Built target H5make_libsettings
  Scanning dependencies of target H5detect
  [ 73%] Building C object Modules/ThirdParty/HDF5/src/itkhdf5/src/CMakeFiles/H5detect.dir/H5detect.c.obj
  Linking C executable ../../../../../../bin/H5detect.exe
  [ 73%] Built target H5detect
  [ 73%] Generating ../H5lib_settings.c
  /bin/sh: ../../../../../../bin/H5make_libsettings.exe: cannot execute binary file
  make[2]: *** [Modules/ThirdParty/HDF5/src/itkhdf5/H5lib_settings.c] Error 126
  make[1]: *** [Modules/ThirdParty/HDF5/src/itkhdf5/src/CMakeFiles/itkhdf5.dir/all] Error 2
  make: *** [all] Error 2
Copy the executables that were created on the host system, ''bin/H5detect.exe'' and ''bin/H5make_libsettings.exe'' to the Windows target and run them,
  H5detect > H5Tinit.c
  H5make_libsettings.exe > H5lib_settings.c
Then copy the results *.c files to ''Modules/ThirdParty/HDF5/src/itkhdf5/'' in the host build tree.  Restart the build,
  make
= In Linux Host for ARM Target =
In this particular case we illustrate
* Target System = Raspberry Pi (ARMv6)
* Build System = Linux (Ubuntu 12.10)
== Major steps ==
# Build your tool chain in the build system
#* This is the set of compiler and linker that must be build in the '''build''' system, but will know how to generate code for the Target system.
#* In this case we use crosstool-ng to build the tool chain
# Create a TryRun ... file in the '''native''' system
#* This could be generated (as a skeleton) with the following commands
=== Building the ToolChain for ARM ===
* The process is described in detail here:
** http://www.kitware.com/blog/home/post/426
* based on the instructions from:
** http://www.bootc.net/archives/2012/05/26/how-to-build-a-cross-compiler-for-your-raspberry-pi/
=== Gathering Configuration settings in the target system ===
Following the advice of the CMake Wiki [http://www.cmake.org/Wiki/CMake_Cross_Compiling]
Put the following in a file called ToolChain.cmake
  # this one is important
  SET(CMAKE_SYSTEM_NAME Linux)
  #this one not so much
  SET(CMAKE_SYSTEM_VERSION 1)
  # specify the cross compiler
  SET(CMAKE_C_COMPILER
  /home/ibanez/local/x-tools/arm-unknown-linux-gnueabi/bin/arm-unknown-linux-gnueabi-gcc)
  SET(CMAKE_CXX_COMPILER
  /home/ibanez/local/x-tools/arm-unknown-linux-gnueabi/bin/arm-unknown-linux-gnueabi-g++)
  # where is the target environment
  SET(CMAKE_FIND_ROOT_PATH
  /home/ibanez/local/x-tools/arm-unknown-linux-gnueabi)
  # 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)
and run it with CMake using the command (in an empty directory)
  cmake -DCMAKE_TOOLCHAIN_FILE=./ToolChain.cmake  ~/src/ITK
This will generate (among many other things) a File called
              TryRunResults.cmake
Then, manually populate, the values of each one of the fields.
The values to be put in this file can be taken from the CMakeCache.txt file of a native build in the Raspberry Pi.
For reference,
* Here is a [[Media:CMakeCache_ITK_RaspberryPi.txt|CMakeCache.txt file]] from a native configuration in the Raspberry Pi.
* Here is the corresponding [[Media:TryRunResults_ITK_RaspberryPi.cmake|TryRunResults.cmake file]] after updating values from the Raspberry Pi.
=== Using the Configuration in the Host ===
Now that you have copied the TryRunResuls.cmake file to the host system, you can use it as an initial cache for configuring the build.
Do the command in the build system.
    cmake -C ~/TryRunResults.cmake -DCMAKE_TOOLCHAIN_FILE=./ToolChain.cmake  ~/src/ITK
once the configuration is completed you can proceed to build ITK by simply typing
    make
=== Dealing with TIFF bootstrapping ===
The build process of the TIFF library requires to first build an executable file called:
* mkg3states (renamed as itkmkg3states in ITK)
in order to generate a file called:
* tif_fax2sm.c
Since, during the cross-compilation process we generate executables that are for a different target architecture, the itkmkg3states file that we built, can't be run in the host to generate the tif_fax2sm.c file.
One way around this is to build the executable for the architecture of the host (e.g. taking it from any other local build of ITK in the host), and use it to replace the itkmkg3states file. Then using it to generate the .c file.
This can be done with the following commands:
* cd ITK_CROSS_COMPILED_BINARY_DIR/Modules/ThirdParty/TIFF/src/itktiff
* cp ITK_NATIVE_BINARY_DIR/Modules/ThirdParty/TIFF/src/itktiff/itkmkg3states  .
* ./itkmkg3states -c const ITK_CROSS_COMPILED_BINARY_DIR/Modules/ThirdParty/TIFF/src/itktiff/tif_fax3sm.c
Then it is possible to continue with the "make" process.
=== Packaging ===
Once the build finishes, we can package ITK with the command:
*  make package
this will produce three files (that are independent of each other)
* ITK-4.4.0-Linux.sh
* ITK-4.4.0-Linux.tar.gz
* ITK-4.4.0-Linux.tar.Z
For example, copying the ITK-4.4.0-Linux.tar.gz file to the target, and expanding it there will provide a local installation of ITK against which it is possible to build ITK applications.
=== Extra Links ===
* http://www.kitware.com/blog/home/post/422
* http://www.kitware.com/blog/home/post/426
* http://www.kitware.com/blog/home/post/428

Latest revision as of 20:45, 5 February 2018

This page describes the procedure to follow when cross compiling ITK for another system.

In this page, we will refer to the system as:

  • Target System: The system where the executables are intended to run.
  • Build System: The system where the executables are built.

In Linux Host for Mac Target

In this particular case we illustrate

  • Target System = Mac
  • Build System = Linux

Major steps

  1. Build your tool chain in the build system
    • This is the set of compiler and linker that must be build in the build system, but will know how to generate code for the Target system.
  2. Create a TryRun ... file in the native system
    • This could be generated (as a skeleton) with the following commands

Building the ToolChain for Darwin

The following is a script developed by Johannes Schindelin (originally intended for FIJI)

Script for Building the Darwing Toolchain in Linux

Gathering Configuration settings in the target system

Following the advice of the CMake Wiki [1]

Put the following in a file called ToolChain.cmake

 # this one is important
 SET(CMAKE_SYSTEM_NAME Linux)
 #this one not so much
 SET(CMAKE_SYSTEM_VERSION 1)
 # specify the cross compiler
 SET(CMAKE_C_COMPILER   /usr/bin/gcc)
 SET(CMAKE_CXX_COMPILER /usr/bin/g++)
 # where is the target environment
 SET(CMAKE_FIND_ROOT_PATH  /usr)
 # 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)

and run it with CMake using the command (in an empty directory)

 cmake -DCMAKE_TOOLCHAIN_FILE=./ToolChain.cmake   ~/src/ITK

This will generate (among many other things) a File called

              TryRunResults.cmake

Then, manually populate, the values of each one of the fields.

The values to be put in this file can be taken from the CMakeCache.txt file of a native build in Darwin.


Finally, copy this file to the build system.

Using the Configuration in the Host

Now that you have copied the TryRunResuls.cmake file to the host system, you can use it as an initial cache for configuring the build.

Do the command in the build system.

   cmake -C ~/TryRunResults.cmake   ~/src/ITK

once the configuration is completed you can proceed to build ITK by simply typing

   make

The full process scripted

The process as a whole has been scripted in the file below

Script for configuring a cross-compilation build

Thanks to Johannes Schindelin for contributing the script.

In Linux Host for Windows Target

In this particular case we illustrate

  • Target System = Windows
  • Build System = Linux

Note: the MXE project has an ITK package! Just

 cd mxe
 make itk


Major steps

  1. Build your tool chain in the build system
    • This is the set of compiler and linker that must be build in the build system, but will know how to generate code for the Target system.
    • In this case we use MinGW as the tool chain
  2. Create a TryRun ... file in the native system
    • This could be generated (as a skeleton) with the following commands

Building the ToolChain for Windows

The MXE project will build the toolchain nicely, and it even creates a CMake toolchain file.

The following is a script developed by Johannes Schindelin (originally intended for FIJI). Script for Building the Windows (MinGW) Toolchain in Linux

Gathering Configuration settings in the target system

Following the advice of the CMake Wiki [2], put the following in a file called ToolChain.cmake

 # this one is important
 SET(CMAKE_SYSTEM_NAME Linux)
 #this one not so much
 SET(CMAKE_SYSTEM_VERSION 1)
 # specify the cross compiler
 SET(CMAKE_C_COMPILER   /usr/bin/gcc)
 SET(CMAKE_CXX_COMPILER /usr/bin/g++)
 # where is the target environment
 SET(CMAKE_FIND_ROOT_PATH  /usr)
 # 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)

Note that if you are using MXE, it already comes with a toolchain file at

 mxe/usr/i686-pc-mingw32/share/cmake/mxe-conf.cmake

Run CMake using the command (in an empty directory)

 cmake -DCMAKE_TOOLCHAIN_FILE=./ToolChain.cmake   ~/src/ITK

This will generate (among many other things) a File called

              TryRunResults.cmake

The values to be put in this file can be taken from the CMakeCache.txt file of a native build in Windows. The CMakeCache.txt can be created by manually running a CMake configuration on Windows. Use this script to populate the TryRun results with the Windows CMakeCache.txt contents.

Using the Configuration in the Host

Now that you have copied the TryRunResuls.cmake file to the host system, you can use it as an initial cache for configuring the build.

Do the command in the build system.

   cmake -C ~/TryRunResults.cmake   ~/src/ITK

once the configuration is completed you can proceed to build ITK by simply typing

   make

The build process will fail when trying to create the HDF5 library.

 [ 73%] Building C object Modules/ThirdParty/HDF5/src/itkhdf5/src/CMakeFiles/H5make_libsettings.dir/H5make_libsettings.c.obj
 Linking C executable ../../../../../../bin/H5make_libsettings.exe
 [ 73%] Built target H5make_libsettings
 Scanning dependencies of target H5detect
 [ 73%] Building C object Modules/ThirdParty/HDF5/src/itkhdf5/src/CMakeFiles/H5detect.dir/H5detect.c.obj
 Linking C executable ../../../../../../bin/H5detect.exe
 [ 73%] Built target H5detect
 [ 73%] Generating ../H5lib_settings.c
 /bin/sh: ../../../../../../bin/H5make_libsettings.exe: cannot execute binary file
 make[2]: *** [Modules/ThirdParty/HDF5/src/itkhdf5/H5lib_settings.c] Error 126
 make[1]: *** [Modules/ThirdParty/HDF5/src/itkhdf5/src/CMakeFiles/itkhdf5.dir/all] Error 2
 make: *** [all] Error 2

Copy the executables that were created on the host system, bin/H5detect.exe and bin/H5make_libsettings.exe to the Windows target and run them,

 H5detect > H5Tinit.c
 H5make_libsettings.exe > H5lib_settings.c

Then copy the results *.c files to Modules/ThirdParty/HDF5/src/itkhdf5/ in the host build tree. Restart the build,

 make

In Linux Host for ARM Target

In this particular case we illustrate

  • Target System = Raspberry Pi (ARMv6)
  • Build System = Linux (Ubuntu 12.10)

Major steps

  1. Build your tool chain in the build system
    • This is the set of compiler and linker that must be build in the build system, but will know how to generate code for the Target system.
    • In this case we use crosstool-ng to build the tool chain
  2. Create a TryRun ... file in the native system
    • This could be generated (as a skeleton) with the following commands

Building the ToolChain for ARM

Gathering Configuration settings in the target system

Following the advice of the CMake Wiki [3]

Put the following in a file called ToolChain.cmake

 # this one is important
 SET(CMAKE_SYSTEM_NAME Linux)
 #this one not so much
 SET(CMAKE_SYSTEM_VERSION 1)
 # specify the cross compiler
 SET(CMAKE_C_COMPILER
 /home/ibanez/local/x-tools/arm-unknown-linux-gnueabi/bin/arm-unknown-linux-gnueabi-gcc)
 SET(CMAKE_CXX_COMPILER
 /home/ibanez/local/x-tools/arm-unknown-linux-gnueabi/bin/arm-unknown-linux-gnueabi-g++)
 # where is the target environment
 SET(CMAKE_FIND_ROOT_PATH
 /home/ibanez/local/x-tools/arm-unknown-linux-gnueabi)
 # 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)


and run it with CMake using the command (in an empty directory)

 cmake -DCMAKE_TOOLCHAIN_FILE=./ToolChain.cmake   ~/src/ITK

This will generate (among many other things) a File called

              TryRunResults.cmake

Then, manually populate, the values of each one of the fields.

The values to be put in this file can be taken from the CMakeCache.txt file of a native build in the Raspberry Pi.

For reference,

Using the Configuration in the Host

Now that you have copied the TryRunResuls.cmake file to the host system, you can use it as an initial cache for configuring the build.

Do the command in the build system.

   cmake -C ~/TryRunResults.cmake -DCMAKE_TOOLCHAIN_FILE=./ToolChain.cmake  ~/src/ITK

once the configuration is completed you can proceed to build ITK by simply typing

   make

Dealing with TIFF bootstrapping

The build process of the TIFF library requires to first build an executable file called:

  • mkg3states (renamed as itkmkg3states in ITK)

in order to generate a file called:

  • tif_fax2sm.c

Since, during the cross-compilation process we generate executables that are for a different target architecture, the itkmkg3states file that we built, can't be run in the host to generate the tif_fax2sm.c file.

One way around this is to build the executable for the architecture of the host (e.g. taking it from any other local build of ITK in the host), and use it to replace the itkmkg3states file. Then using it to generate the .c file.

This can be done with the following commands:

  • cd ITK_CROSS_COMPILED_BINARY_DIR/Modules/ThirdParty/TIFF/src/itktiff
  • cp ITK_NATIVE_BINARY_DIR/Modules/ThirdParty/TIFF/src/itktiff/itkmkg3states .
  • ./itkmkg3states -c const ITK_CROSS_COMPILED_BINARY_DIR/Modules/ThirdParty/TIFF/src/itktiff/tif_fax3sm.c

Then it is possible to continue with the "make" process.

Packaging

Once the build finishes, we can package ITK with the command:

  • make package

this will produce three files (that are independent of each other)

  • ITK-4.4.0-Linux.sh
  • ITK-4.4.0-Linux.tar.gz
  • ITK-4.4.0-Linux.tar.Z

For example, copying the ITK-4.4.0-Linux.tar.gz file to the target, and expanding it there will provide a local installation of ITK against which it is possible to build ITK applications.

Extra Links