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
• objconv (not needed for hosted AROS)

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

• i386-elf-gcc
• netpbm
• cdrtools (not needed for hosted AROS)
• gawk
• py-pil
• wget
• autoconf (if using XCode 2.4 or earlier)

These can be installed with, for example:

> sudo port install i386-elf-gcc

You also need to create a dummy crt0.o file that the configure scripts can use. Create the following file in a text editor and save it as crt0.c:

int _start()
{
}

Then compile and install it with:

> i386-elf-gcc -c crt0.c
> sudo cp crt0.o /opt/local/i386-elf/lib/

If building native AROS, objconv must be manually downloaded, compiled and installed:

> mkdir objconv
> cd objconv
> wget http://www.agner.org/optimize/objconv.zip
> unzip objconv.zip
> unzip source.zip
> g++ -o objconv -O2 *.cpp
> sudo cp objconv /usr/local/bin

Finally, there is a missing symbolic link that needs to be created:

> cd /opt/local/bin
> sudo ln -s i386-elf-gcc-4.3.2 i386-elf-gcc

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 option is 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.

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

``--target=pc-i386``.

``--with-serial-debug=N [default: disabled]``
    Enable serial debug, sending the output to port ``N``.

``--with-bootloader=NAME [default: grub2]``
    Use a specific bootloader.

Compiling

To start the compilation, simply run:

> make

If this doesn't work after a SVN update, 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

> make default-x11keymaptable

> make bootiso-pc-i386

Building several targets from the same source

If you intend to compile several different targets from one source tree, then you first have to go through the configuration step for each of your targets. You can add targets at any time you want. The last target specified to configure is the default target.

To select a specific target when building, simply run make, like this:

> AROS_TARGET_ARCH=$ARCH AROS_TARGET_CPU=$CPU make

Where $ARCH is the architecture of the wanted build, and $CPU is the CPU. E.g., to build AROS/i386-pc you would run:

> AROS_TARGET_ARCH=pc AROS_TARGET_CPU=i386 make

If you are building several ports that use the same CPU, you only have to specify AROS_TARGET_ARCH as the CPU will stay the same.

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

Building AROS in different directories

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

> svn co https://svn.aros.org/svn/aros/trunk/AROS 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.

Compiling HowTos

This step-by-step guide will describe how to prepare the development environment and compile AROS on Ubuntu Linux 6.10 "Edgy Eft". 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 so it'll access the Internet.

> sudo apt-get install subversion gcc-3.4 gawk bison flex netpbm autoconf automake1.4
libx11-dev libc6-dev

> sudo apt-get install localeconf
> sudo dpkg-reconfigure localeconf

> sudo locale-gen "en_US"
> sudo dpkg-reconfigure locales
> export LANG="en_US.ISO-8859-1"

> svn checkout https://svn.aros.org/svn/aros/trunk/AROS
> cd AROS
> svn checkout https://svn.aros.org/svn/aros/trunk/contrib

> export CC="gcc-3.4"
> ./configure

> make