Mac OS X

OS-X-hosted and PC-native versions of AROS can be cross compiled under OS X. There are several additional requirements for compiling AROS on this platform. Firstly, these software packages must be installed:

• XCode
• MacPorts
• XQuartz (not needed for native AROS)

The following MacPort packages then need to be installed to complete the set of required software listed earlier:

• netpbm
• cdrtools (not needed for hosted AROS)
• gawk
• py-pil
• wget
• gsed
• cmake
• autoconf (may not be needed with some versions of XCode)
• automake

These can be installed with, for example:

> sudo port install netpbm

Configuring

There are two ways to build AROS. The preferred method is described in the Appendix: Building AROS in different directories. Here, however, we will build AROS within the source directory. To do this we will first need to configure the AROS build using the following steps:

> cd AROS
> ./configure

You can specify several options to configure. The following options are available for all targets:

--enable-debug=LIST [default: none]

Enable different types of debug. Commas or white space can be used to separate the items in the list. If no list is provided then all is assumed. If --enable-debug is not specified at all, none is the default. Available types:

none

Disables all debug types, and debugging in general.

all

Enables all debug types below.

stack

Enables stack debug.

mungwall

Enables mungwall debug.

modules

Enables modules debug.

--enable-ccache

Enable using ccache on the host to improve compilation times, particularly when recompiling files with the same options.

--with-portssources=DIR

External sources downloaded by the build system will be stored in DIR, so that it can be cached/shared/preserved between builds.

--with-c-compiler=<host c compiler> [default: autodetected]

Specifies the host c compiler to use when compiling code to run on the build host.

--with-cxx-compiler=<host c++ compiler> [default: autodetected]

Specifies the host c++ compiler to use when compiling code to run on the build host.

--with-optimization=FLAGS

Specifies the optimization FLAGS to use when compiling AROS.

--with-paranoia=(yes|no|FLAGS) [default: -Wall -Werror]

Specifies compiler warning FLAGS to enable for paranoia builds.

--with-toolchain=TOOLCHAINFAMILY [default: gnu]

Specifies the TOOLCHAINFAMILY whos cross compiler toochain will be created to build AROS. Currently the Following options are available:

llvm

Uses the LLVM/Clang toolchain to build AROS

gnu

Uses the GNU/GCC toolchain to build AROS. Additonaly, the following configure options are accepted when using the "gnu" toolchain...

--with-binutils-version=VER [default: 2.23.2]

Specifies a specific version of the GNU Binutils package to use for crosscompiling and generating native binaries. Suitable patches must be available (patches are present for binutils 2.25 and 2.30)

--with-gcc-version=VER [default: 4.6.4]

Specifies a specific version of the GNU GCC compiler to use for the cross compiler and native compiler. Suitable patches must be available (patches are present for GCC 6.3.0 and 8.1.0)

--enable-coverage

Enables coverage instrumentation support for programs built in the build system (gcov)

--enable-lto (experimental)

Enables Link Time Optimization(s)

Running ./configure --help will give details of further additional options.

Compiling

To start the compilation, simply run:

> make

If this doesn't work after a Git pull, you can try:

> make clean
> rm -rf bin/
> ./configure {options}
> make

If you use FreeBSD or some other system that does not use GNU Make as the system make, then you should substitute the GNU Make command for the above. For example, under FreeBSD you'll have to install the GNU Make port, then run:

> gmake

After you've made "make" once, and some changes were made to the files, you can use quick compilation of changes using a make <target-name>-quick command.

> make default-x11keymaptable

> make distfiles

Building AROS in different directories

It is possible to configure and build AROS in a directory other than the working copy. For example:

> git clone https://github.com/aros-development-team/AROS.git aros-src
> cd aros-src
> mkdir ../build
> cd ../build
> ../aros-src/configure [...with options as appropriate...]
> make

puts the AROS working copy in the directory "aros-src" and builds it in a separate, parallel directory "build".

Why would you want to do this? Well there are a number of reasons:

• You may want to separate the source and object code and only backup the source / avoid "polluting" the working copy with files generated during the build.
• You may want to put the build directory and the working copy on different physical disks to improve performance.
• You may want to remote mount the working copy on multiple machines, and build for different machines from the same working copy.
• You may want to build multiple configurations from the same working copy.

The last reason above is possibly the most useful. For instance you can have builds for separate architectures and/or debug builds each using the same working copy. Using multiple build directories you can rebuild any or all configurations after an edit without the need to either clean and reconfigure, or identify and copy changes into another working copy.

Building several targets from the same source

If you intend to compile several different targets from one source tree, you should compile outside the source tree (see the previous subsection). For example, you could place your souces in AROS/src, and create a directory for your 32-bit Linux-hosted build at AROS/linux-i386:

> cd AROS
> mkdir linux-i386
> cd linux-i386
> ../src/configure --target=linux-i386
> make

If you then want to also build for 64-bit Linux and Amiga, you can create the directories AROS/linux-x86_64 and AROS/amiga-m68k, and perform similar steps to those above.

Compiling HowTos

This step-by-step guide will describe how to prepare the development environment and compile 32-bit Linux-hosted AROS on Ubuntu Linux 18.04. Let's assume you have a CD image (iso) from an Ubuntu site and have installed the system from it. Also, you should set it up to access the Internet.

> sudo apt-get install git-core gcc g++ make cmake gawk bison flex bzip2
netpbm autoconf automake libx11-dev libxext-dev libc6-dev liblzo2-dev
libxxf86vm-dev libpng-dev libsdl1.2-dev byacc python-mako libxcursor-dev

> sudo apt-get install gcc-multilib libxxf86vm1:i386

> sudo apt-get install libxcursor-dev:i386

> git clone https://github.com/aros-development-team/AROS.git
> cd AROS
> git clone https://github.com/aros-development-team/contrib.git

> ./configure --target=linux-i386

> make