Building Spring Cross Compiled

Development < Building Spring < Building Spring Cross Compiled

Cross-compiling allows you to build for other platforms than the machine you are building on. You can, for example, compile Windows 32-bit binaries on a Linux 64-bit machine.

Obtaining the Source

Tarballs

(For playing online official games on lobby.springrts.com - the spring lobby server)

Using Git is the recommended way to get the sources of the engine. In spite of, you can use the official tarballs to compile Spring without git.

Note: Do NOT use the zip-files from github, they are missing important data to compile Spring.

See Building spring for build instructions.

Git

Spring project page at github

Master repo URI: git://github.com/spring/spring.git
Backup repo: git://git.code.sf.net/p/springrts/code

Branches of interest:

• master - latest stable, enforced for official games on lobby.springrts.com
• maintenance - fixes for the latest stable
• develop - major developments (most active, larger developments)

Assuming the GIT command line client is installed, you can clone (get locally) the repository with the commands below.

Latest Stable (master branch, useless for development purposes, lives as maintenance moving forward)

git clone --recursive git://github.com/spring/spring.git -b master

To later update it (get the changes other people did) with:

git pull --rebase

Maintenance (maintenance branch)

git clone --recursive git://github.com/spring/spring.git -b maintenance

Bleeding-edge (develop branch)

git clone --recursive git://github.com/spring/spring.git -b develop

Working with git

Please note that patches to the code must be done for either develop or maintenance. Such patches can be then sent to one of the developers with repository access. If you are new to git and github, you may want to have a look at this guide to get you started.

Note: you can switch branches this way:<syntaxhighlight lang="bash">

1. (optional) backup your current code changes

git stash

1. switch branch

git checkout $MY_OTHER_BRANCH

1. sometimes needed
2. note, it deletes all your unstashed changes and all non-pushed commits on the new branch,
3. but it doesn't delete untracked files.
4. git reset --hard

1. update/sync with remote repo

git pull --rebase

1. (optional) if you want to apply the code changes backed-up in the first step
2. git stash pop # reapplies your changes and DELETES the backup
3. or
4. git stash apply --index 0 # reapplies your changes and keep the backup (see `git stash list`)

</syntaxhighlight>

Submodules

To obtain the submodules you should clone the repository with --recursive as mentioned above. If you haven't done this, you can execute the following code <syntaxhighlight lang="bash"> git submodule sync git submodule update --init

</syntaxhighlight>

To update the submodules, you have to execute the same commands again or pull normally.

CMake cross compiling

Setting up the cross compiler

The compiler is called MinGW, which is a port of GCC to windows. The version are going to need is MinGW GCC 4.4.0 (which is MinGW 2.7) or later. Most Linux distributions come with MinGW-GCC 4.1.2 only in their standard repos (Summer 2009), so you have to do extra work to get 4.4.0+.

Gentoo instructions for a crosscompiler for can be found here or here.

For Ubuntu, use the repository specified here, and then install the required packages:

sudo apt-get install mingw-x-binutils mingw-x-gcc mingw-x-runtime mingw-x-w32api

For other distros you have to find a way yourself, or use these instructions to get the sources and compile it yourself. When doing so, make sure to use these build flags for gcc:

--with-dwarf2 --enable-shared --disable-sjlj-exceptions --enable-version-specific-runtime-libs

you can add them under src/gcc-core.mk.

Getting Spring's libraries

If Win32 (mingw32) is your target: Auswaschbar has helpfully uploaded all win32 dependencies here. Unpack with 7zip to a directory of your choice (or use the one I recommend below).

Setting up your directories

Here is my recommended layout

~/spring-xcompile/   (or wherever you want to put it all)
___ spring/   (the spring source)
___ win32/    (your target platform)
_______ build/ (the build files for your target will go here)
_______ final/ (the compiled binaries and libs will be installed here)
_______ libs/  (the target libraries you just downloaded, ie: mingw32libs_v13)
_______ win32.cmake (see below)

Create your cmake toolchain

• Create the toolchain file:

>> pico "~/spring-xcompile/win32/win32.cmake"

Example toolchain file

An example should be self-explanatory:

# the name of the target operating system
SET(CMAKE_SYSTEM_NAME Windows)

# which compilers to use for C and C++
SET(CMAKE_C_COMPILER i686-mingw32-gcc)
SET(CMAKE_CXX_COMPILER i686-mingw32-g++)

# here is the target environment located
SET(CMAKE_FIND_ROOT_PATH /usr/i686-mingw32)

# the spring mingw32 dependencies
SET(MINGWLIBS ~/spring-xcompile/win32/libs)

# the path that make install will use to put the final binaries
SET(CMAKE_INSTALL_PREFIX ~/spring-xcompile/win32/final)

Pass this with "-DCMAKE_TOOLCHAIN_FILE=~/spring-xcompile/win32/win32.cmake" to cmake or select it in the gui to make a cross-compilation (see below).

Some Options Explained

• MINGWLIBS: directory where the MinGW library package v18 is (only needed when compiling with mingw)
• CMAKE_BUILD_TYPE: either RELEASE, DEBUG, DEBUG2, DEBUG3 which compiler options to use
• CMAKE_INSTALL_PREFIX: installation prefix (defaults to /usr/local) defines the base directory for installing
• DATADIR, LIBDIR, BINDIR: where to install data, libraries or binaries (relative paths are based on CMAKE_INSTALL_PREFIX, absolute paths are absolute (DESTDIR is still respected))
• APPLICATIONS_DIR, MIME_DIR, PIXMAPS_DIR: where to install freedesktop-files (icons, mime-types and application-description)

Further reference

• CMake FAQ [[1]]
• man CMake
• the CMake documentation (long!) [[2]]

Run CMake

The GUI method

CMake offers a nice Qt4 gui to ease the following steps (to use the gui explained here, cmake must be at least version 2.6.1). Doing so should be straightforward:

• select source directory
• select (and/or create) build directory where temporary files are stored
• hit configure button
• choose your build type:
  • Unix makefile if you are using linux and want to compile linux executables
  • mingw makefiles if you are working on windows
  • Unix makefile with cross compiler setup to cross-compile mingw32 executables, you have to select the toolchain file you want to use (see below)
• configure variables to your need (move the mouse over the options and read the tooltip for further informations on them and or see Section "Options")
• push generate button
• open commandline and do "make" and "make install"

The commandline method

• cd to build directory

>> cd ~user/spring-xcompile/win32/build

• "cmake <path to source tree> <options>" where:
  • <path to source tree> is the path to the spring source directory
  • <options> are defined like "-D<option name>=<value>

• IMPORTANT: depending on your settings you may need to run this command twice. It can't hurt so I recommend doing it anyway.

>> cmake "~user/spring-xcompile/spring" "-DCMAKE_TOOLCHAIN_FILE=~user/spring-xcompile/win32/win32.cmake"

• run "make" and "make install"

>> make && make install DESTDIR=~user/spring-xcompile/win32/final

Package Maintainers Note:

• • doing "make install DESTDIR=/some/path" will install spring in the specified place, putting files in subdirectories like configured. This may be helpfull when making packages so spring don'T get installed on your system for real (see also CMake FAQ [[3]]).
  • You need to update the mime database (update-mime-database) and the kde database (kbuildsycoca) after installing to make the system aware of the newly installed mime types and desktop shortcuts.

SCons cross compiling

configure:

MINGDIR=/usr/i586-mingw32msvc \
MINGWLIBS=${MINGWLIBS_DIR} \
CC=i586-mingw32msvc-gcc \
CXX=i586-mingw32msvc-g++ \
scons configure platform=windows debug=1 \
	mingwlibsdir=${MINGWLIBS_DIR} \
	builddir="${BUILD_DIR}" \
	prefix="${INSTALL_DIR}" \
	datadir="." \
	bindir="." \
	libdir="."

make install:

MINGDIR=/usr/i586-mingw32msvc \
CC=i586-mingw32msvc-gcc \
CXX=i586-mingw32msvc-g++ \
scons install \
	builddir="${BUILD_DIR}"