mp3tag - mp3 tag linux

¿Cómo cruzar compilar para linux x86 con linux amd64, cmake y g++?

Question

+1 por cada información que ayude a completar el cuadro completo. No necesitas saber la respuesta completa. Apreciaré las piezas individuales del rompecabezas igual. Gracias.

Estoy a punto de intentar mi primera compilación cruzada. Busqué en SO y en la web y encontré muchas piezas de información, pero no siempre sé cómo unirlas porque aún faltan algunas.

Mi anfitrión: Linux Kubuntu AMD64.
Objetivo: Linux kubuntu x86 (32 bits) (debería ser fácil, ¿no?)
Herramientas: g ++ y cmake.

Aquí está la información que encontré:

Cómo compilar un binario de 32 bits en una máquina Linux de 64 bits con gcc / cmake
Menciones de exportación CFLAGS = -m32. Esa es una pieza.

Multiplataforma: selección de tipos de datos para usar 32/64 bit
Menciona los tipos de datos. Puede que tenga que prestar atención a eso dentro de mi código.

#ifdef para plataforma de 32 bits
#ifdef para plataforma de 32 bits
enlaces a los siguientes, aunque todavía no estoy seguro de cómo usarlo:
http://predef.sourceforge.net/prearch.html

http://ww.ubuntuforums.org/showthread.php?t=1377396
Lo hice: sudo apt-get install g ++ - multilib

piezas perdidas:

Idealmente, cuando hago ''make'' (con cmake), debería escupir tanto un binario amd64 como uno x86.

Parte de mi CMakeLists.txt tiene este aspecto:

add_definitions(-Wall -pthread)
add_executable (../run.amd64 user.cpp time.cpp init.cpp utils.cpp main.cpp)
target_link_libraries(../run.amd64 cppcms dbixx config++ ctemplate)

¿Cómo presento la bandera -m32 para crear un segundo ejecutable?

¿Debo hacer solo un ejecutable (por ejemplo, para pruebas y depuración), cómo le digo a cmake que haga uno o ambos binarios?

Además, puedes ver que uso algunas bibliotecas de terceros, algunas de las cuales tuve que compilar yo mismo. ¿Esto significa que necesito compilar cada uno de esos binarios para el host de destino también? Algunos usan cmake y otros usan: ./configure; hacer;
¿Qué debo hacer para compilar esas bibliotecas para el host de destino (indicadores para usar, etc.)?

Nota: las bibliotecas enlazadas dinámicamente ya están compiladas e instaladas en la computadora de destino, así que quizás no tenga que preocuparme por este paso ... No estoy seguro: esta es una de mis piezas faltantes ...

Lo que necesito es un tipo de tutorial, o al menos algunas de las piezas faltantes. Actualizaré esta publicación con más detalles sobre lo que logré y cómo.

Gracias.

PD

¿Es posible en absoluto?

Buscando más, encontré esto:
http://www.mail-archive.com/[email protected]/msg26265.html
"El diseño original no parece estar diseñado para nada más que windows-linux o linux-windows compilaciones cruzadas".
cmake NO se prueba para linux amd64 a linux x86.

http://www.cmake.org/Wiki/CMake_Cross_Compiling#FAQ.2FPotential_Problems
"En las instalaciones mixtas de 32/64 bits, la compilación cruzada no se puede usar para compilar solo para 32/64 bits".

??

Answer 1

Aquí está la receta básica que utilizo todo el tiempo para proyectos de cmake.

OPTION(FORCE32 "Force a 32bit compile on 64bit" OFF)
IF(FORCE32)
if(APPLE)
SET(CMAKE_OSX_ARCHITECTURES "i386")
else()
SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -m32")
SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -m32")
endif()
ENDIF()
IF(APPLE)
set(BIN_LIBROOT "macosx")
ELSE()
if(CMAKE_SIZEOF_VOID_P MATCHES "8" AND NOT(FORCE32) )
set(BIN_LIBROOT "linux64")
set(CMAKE_EXECUTABLE_SUFFIX ".bin.x86_64")
set(BIN_RPATH "/$ORIGIN/lib64")
else()
set(BIN_LIBROOT "linux")
set(CMAKE_EXECUTABLE_SUFFIX ".bin.x86")
set(BIN_RPATH "/$ORIGIN/lib")
endif()
set(CMAKE_SKIP_BUILD_RPATH TRUE)
set(CMAKE_BUILD_WITH_INSTALL_RPATH TRUE)
set(CMAKE_INSTALL_RPATH ${BIN_RPATH})
set(CMAKE_INSTALL_RPATH_USE_LINK_PATH FALSE)
ENDIF()

Luego, cada objetivo tiene automáticamente la extensión .bin. $ {Arch} y nunca tengo que pensar en esto para los objetivos que agregué. $ {BIN_LIBROOT} es útil si tiene un montón de bibliotecas precompiladas, ya que puede usarlo para buscar de forma dinámica las bibliotecas en sus direcciones de biblias privadas basadas en la plataforma o el archivo de destino.

Answer 2

Esta es una versión simplificada de lo que uso, y crea binarios x86:

set( TargetName myExe )
set( SOURCES a.cpp b.cpp )
add_executable( ${TargetName} ${SOURCES} )
target_link_libraries( ${TargetName} m pthread stdc++ )
set_target_properties( ${TargetName} PROPERTIES COMPILE_FLAGS -m32 LINK_FLAGS -m32 )

además, utilizará add_definitions para establecer marcas de compilación como -W -Ox -Dxxx etc.

Todas las líneas anteriores en realidad están divididas en archivos separados de cmake, y para obtener un archivo para compilar varios ejecutables, genero un archivo maestro de cmake que contiene todas las configuraciones diferentes que quiero construir:

project( myProject )
set( SOURCES a.cpp b.cpp )
if( ${ConfigurationType} strequal "Debugx86" )
include( debugopts.cmake )
include( x86.cmake )
include( executable.cmake )
...
elseif( ${ConfigurationType} strequal "Releasex64" )
include( debugopts.cmake )
include( x86.cmake )
include( executable.cmake )
...
etc

Luego hay un script de shell de controlador para construir todo. Se requieren opciones de línea de comandos para configurar algunas opciones adicionales y seleccionar construir todo o solo una configuración. Aquí hay un pedazo de eso:

if [ "$myConfig" = "all" -o "$myConfig" = "Debugx86" ]; then
mkdir -p project_Debugx86
cd project_Debugx86
cmkake "$sourceDir" "$cmakeOpts" -DConfigurationType="Debugx86"
make clean
make "$makeopts"
fi
if [ "$myConfig" = "all" -o "$myConfig" = "Releasex64" ]; then
mkdir -p project_Releasex64
cd project_Releasex64
cmkake "$sourceDir" "$cmakeOpts" -DConfigurationType="Releasex64
make clean
make "$makeopts"
fi

Si bien esto no es exactamente lo que pides, funciona perfectamente y hace lo mismo. (No estoy seguro de si es posible en cmake definir cualquier número de objetivos en cmake, y tenerlos integrados en un solo archivo). Solo toma un poco de tiempo escribir el generador para estos archivos, pero una vez que se hace todo esto, Lo que hay que hacer es apuntar el generador a un directorio con fuentes, dejarlo correr, luego invocar el script de compilación para hacer todo.

Answer 3

Esta solución le permitirá compilar de forma cruzada su proyecto cmake en un host linux64 dirigido a 32 bits, en sistemas con soporte multi-arch. Utiliza una cadena de herramientas cmake "falsa" por lo que CMAKE de alguna manera "cree" que está en el sistema de 32 bits, por lo que no se necesitan modificaciones adicionales dentro de los archivos de proyecto de cmake, no hay configuraciones especiales ni configuraciones especiales (bueno, casi).

1. Instalar soporte multilib:

   $sudo apt-get install gcc-multilib

2. Crear un "falso" linux32 toolchain

Primero, creamos un compilador i686 "falso". Vaya a donde reside su CMakeLists.txt y cree un directorio bin. Abra su editor preferido y cree este sencillo script bash para el compilador gcc.

#!/bin/sh
/usr/bin/gcc -m32 "$@"

Como puede ver, solo es hacer una llamada al compilador del sistema agregando la marca -m. Guarda esto como i686-linux-gnu-gcc. Haz lo mismo para el compilador g ++.

#!/bin/sh
/usr/bin/g++ -m32 "$@"

Guárdelo como i686-linux-gnu-g ++. Recuerda configurar los indicadores ejecutables en estos scrips.

Cree también un enlace simbólico al sistema binario en esta forma

$ln /usr/bin/ar i686-linux-gnu-ar

Por fin crear el archivo toolchain-linux32.cmake

# the name of the target operating system
set(CMAKE_SYSTEM_NAME Linux)
# Which compilers to use for C and C++
set(CMAKE_C_COMPILER ${CMAKE_SOURCE_DIR}/bin/i686-linux-gnu-gcc)
set(CMAKE_CXX_COMPILER ${CMAKE_SOURCE_DIR}/bin/i686-linux-gnu-g++)

y cree el directorio de compilación y llame a cmake con el archivo de herramientas como argumento

$mkdir build && cd build
$cmake -DCMAKE_TOOLCHAIN_FILE=../toolchain-linux32.cmake ..

y tu hecho !!!!!

Escribiré una guía más completa here , que cubre algunos problemas que tengo con las bibliotecas que no son compatibles con múltiples bibliotecas

Answer 4

Si desea utilizar un archivo de herramientas, hay una solución más sencilla (IMHO) que la que propone @auledoom. No es necesario que escriba los scripts de envoltura de shell, simplemente coloque esto en el archivo de la cadena de herramientas:

# the name of the target operating system
set(CMAKE_SYSTEM_NAME Linux)
# Which compilers to use for C and C++
set(CMAKE_C_COMPILER gcc -m32)
set(CMAKE_CXX_COMPILER g++ -m32)

Esto lo convertirá en una "variable de lista" en cmake. Esta solución funciona para mí. El beneficio del archivo de la cadena de herramientas es que también puede definir rutas para bibliotecas de 32 bits, etc., que generalmente son diferentes de las rutas estándar.

Answer 5

Todo lo que necesita es agregar -m32 a CFLAGS y CXXFLAGS cuando ejecute CMake. Esto se puede hacer a través de variables de entorno:

$ CFLAGS=-m32 CXXFLAGS=-m32 cmake .

o configurando las variables CMake correspondientes:

$ cmake -DCMAKE_C_FLAGS=-m32 -DCMAKE_CXX_FLAGS=-m32 .

Esto puede probarse fácilmente con un simple proyecto CMake:

$ uname -m
x86_64
$ CFLAGS=-m32 CXXFLAGS=-m32 cmake .
-- The C compiler identification is GNU 4.8.1
-- The CXX compiler identification is GNU 4.8.1
....
$ make
Scanning dependencies of target foo
[100%] Building CXX object CMakeFiles/foo.dir/foo.cc.o
Linking CXX executable foo
[100%] Built target foo
$ file foo
foo: ELF 32-bit LSB executable, Intel 80386, version 1 (SYSV), dynamically linked (uses shared libs), for GNU/Linux 2.6.24, BuildID[sha1]=0x5b1871446c92cbdcbf905583e16189f68f3bf5f2, not stripped

donde CMakeLists.txt es un archivo trivial de CMake:

project(TEST)
add_executable(foo foo.cc)

y foo.cc es el siguiente:

int main () {}