CMake create and link 32bit and 64bit versions of library

Question

I am trying to compile the following code twice, once with -m32 and once without:

// File mylib.cc

#include <iostream>

void print_int_size() {
  std::cout << sizeof(int*) << std::endl;
}


// File main.cc

void print_int_size();

int main() {
  print_int_size();
  return 0;
}

I have the following in my CMakeLists.txt:

project (Link32b VERSION 0.91 LANGUAGES CXX)


add_library ( mylib STATIC mylib.cc )
add_library ( mylib_32b STATIC mylib.cc )

target_compile_options ( mylib_32b PUBLIC -m32 )

add_executable ( main main.cc )
add_executable ( main_32b main.cc )

target_compile_options ( main_32b PRIVATE -m32 )

target_link_libraries ( main PRIVATE mylib )
target_link_libraries ( main_32b PRIVATE mylib_32b )

I get the following output when compiling (similar with gcc):

Scanning dependencies of target mylib
[ 12%] Building CXX object CMakeFiles/mylib.dir/mylib.cc.o
[ 25%] Linking CXX static library libmylib.a
[ 25%] Built target mylib
Scanning dependencies of target main
[ 37%] Building CXX object CMakeFiles/main.dir/main.cc.o
[ 50%] Linking CXX executable main
[ 50%] Built target main
Scanning dependencies of target mylib_32b
[ 62%] Building CXX object CMakeFiles/mylib_32b.dir/mylib.cc.o
[ 75%] Linking CXX static library libmylib_32b.a
[ 75%] Built target mylib_32b
Scanning dependencies of target main_32b
[ 87%] Building CXX object CMakeFiles/main_32b.dir/main.cc.o
[100%] Linking CXX executable main_32b
ld: warning: ignoring file CMakeFiles/main_32b.dir/main.cc.o, file was built for i386 which is not the architecture being linked (x86_64): CMakeFiles/main_32b.dir/main.cc.o
ld: warning: ignoring file libmylib_32b.a, file was built for archive which is not the architecture being linked (x86_64): libmylib_32b.a
Undefined symbols for architecture x86_64:
  "_main", referenced from:
     implicit entry/start for main executable
ld: symbol(s) not found for architecture x86_64
clang: error: linker command failed with exit code 1 (use -v to see invocation)
make[2]: *** [main_32b] Error 1
make[1]: *** [CMakeFiles/main_32b.dir/all] Error 2
make: *** [all] Error 2

What am I missing here?

===

UPDATE: It is curious that setting CMAKE_CXX_FLAGS to include -m32 makes the example work. However, I would like to get it done without setting variables, i.e., follow the mordern target-based approach.

Answer 1

The -m32 flag is not "inherited" for linking purposes:

target_compile_options ( <lib> PUBLIC -m32 )
target_link_libraries ( <target> PRIVATE <lib> ) // Does not link with `-m32`.

Note that the above causes <target> to be compiled with -m32, since target_link_libraries "inherits" PUBLIC compilation option from <lib>. However, the flag is not passed to the linker.

Moreover, there is no target_link_options command, and so, one cannot insert the line target_link_options ( <link> PUBLIC -m32 ) to solve the problem.

Instead, per this answer (modified slightly), the correct approach is

target_compile_options ( <lib> PUBLIC -m32 )
set_target_properties ( <target> PROPERTIES LINK_FLAGS -m32 )
target_link_libraries ( <target> PRIVATE <lib> )

Answer 2

To streamline the maintenance of your project, I suggest you keep the build system as simple as possible and instead configure and build the project twice:

• one build for the 64-bit binaries

• one build for the 32-bit binaries:

  • by setting the CXXFLAGS and CFLAGS environment variables to -m32 (approach 1)
  • or by setting the three environment variables AS, CXX and CC (approach 2)

Simplify your example project

Make also sure to add cmake_minimum_required, otherwise you would get the error VERSION not allowed unless CMP0048 is set to NEW.

cmake_minimum_required(VERSION 3.10)
project (Link VERSION 0.91 LANGUAGES CXX)
add_library ( mylib STATIC mylib.cc )
add_executable ( main main.cc )
target_link_libraries ( main PRIVATE mylib )

By having a simpler build system that do not hard-code assumption about the toolchain, you implicitly enable support for cross-platform and different environment like ARM, etc ... it can also make the continuous integration easier. For example, on CircleCI, you would have two build jobs (one for 64-bit, one for 32-bit) both building a simple project.

install required i386 libraries

On Ubuntu, this could be done like this

sudo apt-get install \
  gcc-multilib \
  g++-multilib \
  libc6:i386 \
  libstdc++6:i386

Other dependency would be installed using packageName:i386

Step-by-step: Approach 1

Assuming we have the following directory structure:

<root>
  |
  |-src
  |  |--- CMakeLists.txt
  |  |--- main.cc
  |  |--- mylib.cc
  |
  |-build
  |   |-- ...
  |
  |-build-32
      |-- ...

you could complie the 32-bit version by simply doing:

CFLAGS=-m32 CXXFLAGS=-m32 cmake -Hsrc -Bbuild-32

Step-by-step: Approach 2

The goal of the approach 2 is to introduce the idea of cross-compilation.

In the last section, you will then learn about dockcross/linux-32 docker images that internally applies the same principle.

Create three wrapper scripts for as, gcc and g++

Below are the content of three shell scripts:

• i686-linux-gnu-as

#!/bin/bash exec as -m32 "$@"

• i686-linux-gnu-gcc

#!/bin/bash exec gcc -m32 "$@"

• i686-linux-gnu-g++

#!/bin/bash exec g++ -m32 "$@"

Compile

Assuming we have the following directory structure:

<root>
  |-bin
  |  |- i686-linux-gnu-as
  |  |- i686-linux-gnu-g++
  |  |- i686-linux-gnu-gcc
  |
  |-src
  |  |--- CMakeLists.txt
  |  |--- main.cc
  |  |--- mylib.cc
  |
  |-build
  |   |-- ...
  |
  |-build-32
      |-- ...

you would respectively do

64-bit

$ cmake -Hsrc -Bbuild; cmake --build ./build
-- The CXX compiler identification is GNU 5.2.1
-- Check for working CXX compiler: /usr/bin/c++
-- Check for working CXX compiler: /usr/bin/c++ -- works
-- Detecting CXX compiler ABI info
-- Detecting CXX compiler ABI info - done
-- Detecting CXX compile features
-- Detecting CXX compile features - done
-- Configuring done
-- Generating done
-- Build files have been written to: /tmp/scratch/build
[...]
[100%] Built target main

$ file ./build/main 
./build/main: ELF 64-bit LSB executable, x86-64, version 1 (SYSV), dynamically linked, interpreter /lib64/ld-linux-x86-64.so.2, for GNU/Linux 2.6.32, BuildID[sha1]=e28e610f85cd4a2ab29e38ed58c1cb928f4aaf33, not stripped

$ ./build/main 
4

32-bit

$ CXX=$(pwd)/bin/i686-linux-gnu-g++ \
  CC=$(pwd)/bin/i686-linux-gnu-gcc \
  AS=$(pwd)/bin/i686-linux-gnu-as linux32 \
  bash -c "cmake -Hsrc -Bbuild-32; cmake --build ./build-32/"
-- The CXX compiler identification is GNU 5.2.1
-- Check for working CXX compiler: /tmp/scratch/bin/i686-linux-gnu-g++
-- Check for working CXX compiler: /tmp/scratch/bin/i686-linux-gnu-g++ -- works
-- Detecting CXX compiler ABI info
-- Detecting CXX compiler ABI info - done
-- Detecting CXX compile features
-- Detecting CXX compile features - done
-- Configuring done
-- Generating done
[...]
[100%] Built target main

$ file ./build-32/main 
./build-32/main: ELF 32-bit LSB executable, Intel 80386, version 1 (SYSV), dynamically linked, interpreter /lib/ld-linux.so.2, for GNU/Linux 2.6.32, BuildID[sha1]=b7f5781f66a28e28d28eda2b798b671c1e89e22a, not stripped

$ ./build-32/main 
4

Now to understand why sizeof(int) is the same on both the 64 and 32-bit build, consider reading C/C++: sizeof(short), sizeof(int), sizeof(long), sizeof(long long), etc... on a 32-bit machine versus on a 64-bit machine

Streamlining the compilation using dockcross

Now, to easily compile to 32-bit you could also use the dockcross image dockcross/linux-x86. See https://github.com/dockcross/dockcross#readme

docker pull dockcross/linux-x86
docker run -ti --rm dockcross/linux-x86 > dockcross-linux-x86
chmod u+x dockcross-linux-x86

Then to compile, you would do:

dockcross-linux-x86  bash -c "cmake -Hsrc -Bbuild-32; cmake --build ./build-32/"

Answer 3

Addition to OP's answer: Cmake 3.13+ has target_link_options command therefore you can write: target_link_options(<target> PRIVATE "-m32")