Hello world on RISC-V with QEMU

I wanted to create a minimal, Hello world style, program, for RISC-V.

I wanted the program to run on Ubuntu, as well as on MacOS, and I wanted to use QEMU as RISC-V simulator.

QEMU – Ubuntu

For Ubuntu, I installed QEMU by following instructions on the QEMU site, which led to commands, as

git clone https://git.qemu.org/git/qemu.git
cd qemu
git submodule init
git submodule update --recursive
mkdir objdir
cd objdir
../configure --target-list=riscv32-softmmu --prefix=/home/$USER/prog/qemu_riscv

The configure step gave an error, as

ola@ola-VirtualBox:~/mw/qemu/objdir$ ../configure --target-list=riscv32-softmmu --prefix=/home/$USER/prog/qemu_riscv

ERROR: pkg-config binary 'pkg-config' not found

ola@ola-VirtualBox:~/mw/qemu/objdir$ 

I realized that this was due to lack of programs on my newly installed Ubuntu 18.04.3 on Virtualbox.

I installed pkg-config, by doing

sudo apt install pkg-config

after which I got more errors, which led to

sudo apt install libglib2.0-dev 
sudo apt install libpixman-1-dev

which in turn led to a successful configure command.

I could then build, using

make

and install, using

make install

The installation was then tested, as

ola@ola-VirtualBox:~/mw/qemu/objdir$ /home/$USER/prog/qemu_riscv/bin/qemu-system-riscv32 --help | head
QEMU emulator version 4.1.93 (v4.2.0-rc3-dirty)
Copyright (c) 2003-2019 Fabrice Bellard and the QEMU Project developers
usage: qemu-system-riscv32 [options] [disk_image]

'disk_image' is a raw hard disk image for IDE hard disk 0

Standard options:
-h or -help     display this help and exit
-version        display version information and exit
-machine [type=]name[,prop[=value][,...]]
ola@ola-VirtualBox:~/mw/qemu/objdir$ 

QEMU – macOS Catalina

For macOS, I had already done an installation of QEMU on macOS Mojave.

I followed the steps from this experience, but now on macOS Catalina, and changing the configure command from

../configure --target-list=riscv32-softmmu --prefix=/Users/$USER/qemu_riscv

to

../configure --target-list=riscv32-softmmu --prefix=/Users/$USER/prog/qemu_riscv

I also noted that a parallel make

make -j

was successful.

I checked by my installation, by doing.

objdir oladahl$ /Users/$USER/prog/qemu_riscv/bin/qemu-system-riscv32 --help | head
QEMU emulator version 4.1.94 (v4.2.0-rc4-2-g02f9c885ed)
Copyright (c) 2003-2019 Fabrice Bellard and the QEMU Project developers
usage: qemu-system-riscv32 [options] [disk_image]

'disk_image' is a raw hard disk image for IDE hard disk 0

Standard options:
-h or -help     display this help and exit
-version        display version information and exit
-machine [type=]name[,prop[=value][,...]]
objdir oladahl$ 

Toolchain

As the next step, I wanted to install a toolchain.

I decided to use this RISC-V toolchain.

Ubuntu

Following the instructions, I did, on Ubuntu

git clone https://github.com/riscv/riscv-gnu-toolchain
cd riscv-gnu-toolchain

followed by

git submodule update --init --recursive

which took some time.

I installed programs, as recommended, by doing

sudo apt-get install autoconf automake autotools-dev curl libmpc-dev libmpfr-dev libgmp-dev gawk build-essential bison flex texinfo gperf libtool patchutils bc zlib1g-dev libexpat-dev

A configure was then done, for a 32-bit instruction set, using information from the Github site, as

mkdir objdir
cd objdir/
../configure --prefix=/home/$USER/prog/gcc_riscv --with-arch=rv32gc --with-abi=ilp32d

I built the toolchain, at first trying with

make -j

which led to an out-of-memory situation, with prints such as

cc1plus: out of memory allocating 65536 bytes after a total of 2252800 bytes
virtual memory exhausted: Cannot allocate memory
virtual memory exhausted: Cannot allocate memory

cc1plus: out of memory allocating 240809 bytes after a total of 1343488 bytes
virtual memory exhausted: Cannot allocate memory
virtual memory exhausted: Cannot allocate memory
virtual memory exhausted: Cannot allocate memory

I changed to a sequential make

make

which was successful.

I checked that I could start gcc, using

ola@ola-VirtualBox:~/mw/riscv-gnu-toolchain/objdir$ /home/$USER/prog/gcc_riscv/bin/riscv32-unknown-elf-gcc -v
Using built-in specs.
COLLECT_GCC=/home/ola/prog/gcc_riscv/bin/riscv32-unknown-elf-gcc
COLLECT_LTO_WRAPPER=/home/ola/prog/gcc_riscv/libexec/gcc/riscv32-unknown-elf/9.2.0/lto-wrapper
Target: riscv32-unknown-elf
Configured with: /home/ola/mw/riscv-gnu-toolchain/objdir/../riscv-gcc/configure --target=riscv32-unknown-elf --prefix=/home/ola/prog/gcc_riscv --disable-shared --disable-threads --enable-languages=c,c++ --with-system-zlib --enable-tls --with-newlib --with-sysroot=/home/ola/prog/gcc_riscv/riscv32-unknown-elf --with-native-system-header-dir=/include --disable-libmudflap --disable-libssp --disable-libquadmath --disable-libgomp --disable-nls --disable-tm-clone-registry --src=../../riscv-gcc --disable-multilib --with-abi=ilp32d --with-arch=rv32gc --with-tune=rocket 'CFLAGS_FOR_TARGET=-Os   -mcmodel=medlow' 'CXXFLAGS_FOR_TARGET=-Os   -mcmodel=medlow'
Thread model: single
gcc version 9.2.0 (GCC) 
ola@ola-VirtualBox:~/mw/riscv-gnu-toolchain/objdir$ 
macOS Catalina

On macOS Catalina, I installed programs as

brew install gawk gnu-sed gmp mpfr libmpc isl zlib expat

Following the instructions, I cloned the repo, as

git clone https://github.com/riscv/riscv-gnu-toolchain
cd riscv-gnu-toolchain

followed by

git submodule update --init --recursive

which took some time.

A configure was done, for a 32-bit instruction set, using information from the Github site, as

mkdir objdir
cd objdir/
../configure --prefix=/Users/$USER/prog/gcc_riscv --with-arch=rv32gc --with-abi=ilp32d

I built the toolchain, using parallel make, as

make -j

which was successful.

I checked that I could start gcc, using

$ /Users/$USER/prog/gcc_riscv/bin/riscv32-unknown-elf-gcc -v
Using built-in specs.
COLLECT_GCC=/Users/oladahl/prog/gcc_riscv/bin/riscv32-unknown-elf-gcc
COLLECT_LTO_WRAPPER=/Users/oladahl/prog/gcc_riscv/libexec/gcc/riscv32-unknown-elf/9.2.0/lto-wrapper
Target: riscv32-unknown-elf
Configured with: /Users/oladahl/mw/riscv-gnu-toolchain/objdir/../riscv-gcc/configure --target=riscv32-unknown-elf --prefix=/Users/oladahl/prog/gcc_riscv --disable-shared --disable-threads --enable-languages=c,c++ --with-system-zlib --enable-tls --with-newlib --with-sysroot=/Users/oladahl/prog/gcc_riscv/riscv32-unknown-elf --with-native-system-header-dir=/include --disable-libmudflap --disable-libssp --disable-libquadmath --disable-libgomp --disable-nls --disable-tm-clone-registry --src=../../riscv-gcc --disable-multilib --with-abi=ilp32d --with-arch=rv32gc --with-tune=rocket 'CFLAGS_FOR_TARGET=-Os   -mcmodel=medlow' 'CXXFLAGS_FOR_TARGET=-Os   -mcmodel=medlow'
Thread model: single
gcc version 9.2.0 (GCC) 
$ 

A program

I decided to write an assembly program, and to use a simulated UART in QEMU as the means for printing.

Looking at the 32-bit instruction set, in the The RISC-V Instruction Set Manual for the Unprivileged ISA, available as one of the RISC-V Specifications, and also using information from this page for the rv8 simulator, I came up with a program as

    .global _start

_start:

    lui t0, 0x10010

    andi t1, t1, 0
    addi t1, t1, 72
    sw t1, 0(t0)

    andi t1, t1, 0
    addi t1, t1, 101
    sw t1, 0(t0)

    andi t1, t1, 0
    addi t1, t1, 108
    sw t1, 0(t0)

    andi t1, t1, 0
    addi t1, t1, 108
    sw t1, 0(t0)

    andi t1, t1, 0
    addi t1, t1, 111
    sw t1, 0(t0)

    andi t1, t1, 0
    addi t1, t1, 10
    sw t1, 0(t0)

finish:
    beq t1, t1, finish

Here, the UART address is indicated by the value 0x10010, which is used in the first instruction as

    lui t0, 0x10010

I found the UART address by first practising building of a hello world program from riscv-probe, where I also learned how to create a linker script.

After this, I looked in the QEMU source code, where I found the file hw/riscv/sifive_u.c, in which the UART address is found in a struct, defined (with values for entries not related to UART0 omitted) as

static const struct MemmapEntry {
     hwaddr base;
     hwaddr size;
} sifive_u_memmap[] = {
...
    [SIFIVE_U_UART0] =    { 0x10010000,     0x1000 },
...
};

Considering that the lui instruction loads its immediate value into the upper 20 bits of the register used in the instruction, we see that the value 0x10010000 can be loaded in to a register, in this case t0, by doing

    lui t0, 0x10010

Using a makefile, as

hello: hello.o link.lds
	riscv32-unknown-elf-ld -T link.lds -o hello hello.o

hello.o: hello.s
	riscv32-unknown-elf-as -o hello.o hello.s

clean:
	rm hello hello.o

where the file link.lds has the same content as the riscv-probe linker script, I could build and run the program, on Ubuntu, as

export PATH=/home/$USER/prog/gcc_riscv/bin/:$PATH
make
/home/$USER/prog/qemu_riscv/bin/qemu-system-riscv32 -machine sifive_u -nographic -kernel hello

with printouts as

$ /home/$USER/prog/qemu_riscv/bin/qemu-system-riscv32 -machine sifive_u -nographic -kernel hello
qemu-system-riscv32: warning: No -bios option specified. Not loading a firmware.
qemu-system-riscv32: warning: This default will change in a future QEMU release. Please use the -bios option to avoid breakages when this happens.
qemu-system-riscv32: warning: See QEMU's deprecation documentation for details.
Hello
Hello
QEMU: Terminated
$ 

On macOS Catalina, I did

export PATH=/Users/$USER/prog/gcc_riscv/bin/:$PATH
make
/Users/$USER/prog/qemu_riscv/bin/qemu-system-riscv32 -machine sifive_u -nographic -kernel hello

with printouts as

$ /Users/$USER/prog/qemu_riscv/bin/qemu-system-riscv32 -machine sifive_u -nographic -kernel hello
qemu-system-riscv32: warning: No -bios option specified. Not loading a firmware.
qemu-system-riscv32: warning: This default will change in a future QEMU release. Please use the -bios option to avoid breakages when this happens.
qemu-system-riscv32: warning: See QEMU's deprecation documentation for details.
Hello
Hello
QEMU: Terminated
$ 

In both cases (Ubuntu and macOS Catalina), I terminated QEMU using Ctrl-A x. Also, I don’t know why the Hello string was printed twice.

Installing RISC-V QEMU on macOS Mojave

In my ongoing book project, I have decided to change architecture, from OpenRISC to RISC-V.

My main motivation (yes, you might want to call it procrastination), is to be more aligned with current topics, and to have access to a broader range of reference material.

As a first step, I wanted to run on my macOS Mojave computer (later on, I should also use Ubuntu).

I downloaded QEMU using Git, as

git clone https://git.qemu.org/git/qemu.git
cd qemu
git submodule init
git submodule update --recursive

Configure was done, as

mkdir objdir
cd objdir
../configure --target-list=riscv32-softmmu --prefix=/Users/$USER/qemu_riscv

This resulted in an error, as

ERROR: pkg-config binary 'pkg-config' not found 

I guessed (based on earlier Mac experiences) that I could have use of brew. From the Homebrew page, I learned how to install brew, as

/usr/bin/ruby -e "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/install)"

I did this, and then tried to install pkg-config, as

brew install pkg-config

Trying the configure command again, as

../configure --target-list=riscv32-softmmu --prefix=/Users/$USER/qemu_riscv

resulted in the error message

ERROR: glib-2.40 gthread-2.0 is required to compile QEMU

I guessed that brew could help me also here, so I tried

brew install glib

The configure command now gave

ERROR: pixman >= 0.21.8 not present.
       Please install the pixman devel package.

Continuing with brew, as

brew install pixman

resulted in a successful configure command.

I tried building, using

make -j

which finished with errors, as

clang: error: unable to execute command: posix_spawn failed: Resource temporarily unavailable
make: *** [util/drm.o] Error 1
make: *** Waiting for unfinished jobs....
  CC      util/guest-random.o
clang: error: unable to execute command: posix_spawn failed: Resource temporarily unavailable
make: *** [util/qsp.o] Error 1

Using a sequential make, as

make

resulted in a successful build.

I could then install QEMU, by doing

make install

As a sanity check of the installation, I did

Olas-MacBook:objdir ola$ /Users/ola/qemu_riscv/bin/qemu-system-riscv32 --help | head
QEMU emulator version 4.0.90 (v4.1.0-rc0)
Copyright (c) 2003-2019 Fabrice Bellard and the QEMU Project developers
usage: qemu-system-riscv32 [options] [disk_image]

'disk_image' is a raw hard disk image for IDE hard disk 0

Standard options:
-h or -help     display this help and exit
-version        display version information and exit
-machine [type=]name[,prop[=value][,...]]

Building ghdl from source for Ubuntu 16.04 – mcode version

Based on input from Patrick Lehmann, I decided to re-install ghdl, now using the official GitHub site.

I learned from the README file how to build the mcode variant. I tried, and it worked fine (and it was much simpler than the gcc-based approach I tried earlier)!

Here are the commands that I used.

I downloaded and installed an Ada compiler, as instructed, and I proceeded with the build and install of ghdl, by first setting the PATH to include my newly installed Ada compiler, as

export PATH=/usr/gnat/bin:$PATH

I cloned the repo, using

git clone https://github.com/ghdl/ghdl.git

I configured and built ghdl, using

cd ghdl
./configure --prefix=/usr/local/ghdl_mcode
make

The installation was then done, as

ghdl:-$ sudo -i
# cd 
# PATH=/usr/gnat/bin/:$PATH make install
... 
...
# exit

That was all!

I could now build and run my hello world example, from my work-in-progress book about building a computer, as

vhdl:-$ export PATH=/usr/local/ghdl_mcode/bin/:$PATH
vhdl:-$ ghdl -a hello.vhdl
vhdl:-$ ghdl -e hello_world
vhdl:-$ ghdl -r hello_world
Hello, world
vhdl:-$ 

Layered books

I have started over. The book creation project, previously reported on Books with Views is continued, but as Layered Books.

I moved from XML to pandoc, replacing many lines of Python with significantly fewer lines of Python, for processing the book source files and generating output.

For the moment, there is one book, in html format.

Installing ghdl from source on Ubuntu 16.04



NOTE – this page is outdated – please use updated page instead.



I wanted to reinstall ghdl on my new Ubuntu 16.04. My first idea was to use the method I used for the previous Ubuntu version, where I downloaded a ghdl package from this page with Debian packages.

But when I looked at the page now, I did not find any package that I could get to work on Ubuntu 16.04.

I decided to try an installation from source.

I found out that the source code could be downloaded from this ghdl-updates sourceforge page.

From the information about branches, I could see the version numbers for stable versions. I chose to download the 0.33 version.

The source code download was done using git clone, as

git clone git://git.code.sf.net/p/ghdl-updates/ghdl-updates.git ghdl-updates-ghdl-updates.git

and the 0.33 branch was checked out as

cd ghdl-updates-ghdl-updates.git
git branch
git checkout ghdl-0.33

I looked in the README file and learned that it was possible to build ghdl with gcc as backend. I decided to try this alternative. Another alternative was called mcode, but it was only available for 32-bit Ubuntu, and a third alternative was to use llvm.

The first step was to obtain an Ada compiler.

I installed gnat by doing

sudo apt install gnat

From the README file I then learned that I should download the gcc 4.9 source. I did this by doing

wget ftp://ftp.gnu.org/gnu/gcc/gcc-4.9.4/gcc-4.9.4.tar.bz2
tar xvjf gcc-4.9.4.tar.bz2

I then configured gcc, as instructed in the ghdl source code README file, via the ghdl source configure script, using the path to my downloaded gcc source as argument, by doing

cd ghdl-updates-ghdl-updates.git/
./configure --with-gcc=/home/ola/ghdl/gcc/gcc-4.9.4/
make copy-sources
cd ..

It was now required to download and build some auxiliary packages. I did this, for the package gmp, by doing

wget ftp://gcc.gnu.org/pub/gcc/infrastructure/gmp-4.3.2.tar.bz2
tar xvjf gmp-4.3.2.tar.bz2
mkdir gmp-4.3.2/gmp-objs/
cd gmp-4.3.2/gmp-objs/
../configure --prefix=/usr/local --disable-shared
make
sudo make install
cd ../..

followed by the package mpfr, as

wget ftp://gcc.gnu.org/pub/gcc/infrastructure/mpfr-2.4.2.tar.bz2
tar xvjf mpfr-2.4.2.tar.bz2
mkdir mpfr-2.4.2/mpfr-objs/
cd mpfr-2.4.2/mpfr-objs/
../configure --prefix=/usr/local --disable-shared --with-gmp=/usr/local
make
sudo make install
cd ../..

and finally, the third package mpc, as

wget ftp://gcc.gnu.org/pub/gcc/infrastructure/mpc-0.8.1.tar.gz
tar xvzf mpc-0.8.1.tar.gz
mkdir mpc-0.8.1/mpc-objs/
cd mpc-0.8.1/mpc-objs/
../configure --prefix=/usr/local --disable-shared --with-gmp=/usr/local
make
sudo make install
cd ../..

It was now time to build the actual ghdl. Since we had decided to use gcc as backend, we accomplish the task of building ghdl by building gcc. So we go back to our directory where we unpacked the gcc sources.

In that directory, we do configuration as

cd gcc-4.9.4
mkdir gcc-objs
cd gcc-objs/
../configure --prefix=/opt/ghdl-updates --enable-languages=c,vhdl --disable-bootstrap --with-gmp=/usr/local --disable-lto --disable-multilib

In the above configuration step, we have selected the prefix as /opt/ghdl-updates. The reason for this is to avoid a collision with an already existing gcc compiler (which we already have on our system – and which we need for the build of ghdl).

For the actual build step, we need to do make. Here, I ran into a problem since the program gnat1 was assumed to be used (instead of gnat). The error was seen when doing a plain

make

and it showed up, after a while, as

gnatbind -Lgrt_ -o run-bind.adb -n ghdl_main.ali
gcc -c -O2 -g -gnatec../../../gcc/vhdl/grt/grt.adc -gnat05 -o run-bind.o run-bind.adb
gcc: error trying to exec 'gnat1': execvp: No such file or directory
Makefile:586: recipe for target 'run-bind.o' failed

I found this searchcode page, where the problem, and a solution, were described.

Using this newfound piece of information, I located gnat1 by doing

$ find /usr -name gnat1
/usr/lib/gcc/x86_64-linux-gnu/4.9/gnat1

I then used this directory as a part of the PATH when doing make, as

PATH=/usr/lib/gcc/x86_64-linux-gnu/4.9:$PATH make

This resulted in a successful build.

Assuming that the PATH used for make was needed also when doing make install, I started a root shell as

sudo -i

and in that shell, after having done cd to the gcc-objs directory, I did

PATH=/usr/lib/gcc/x86_64-linux-gnu/4.9:$PATH make install MAKEINFO=true

This completed the installation of ghdl!

I could use ghdl, on the first example from the book Into Computers, after having set the PATH as

export PATH=/opt/ghdl-updates/bin/:$PATH

as described in the book, by doing

$ ghdl -a hello.vhdl
$ ghdl -e hello_world
$ ghdl -r hello_world
Hello, world
$

Installing QEMU on Ubuntu 16.04

These are my experiences from installing QEMU from source, on Ubuntu 16.04.1.

Starting from the QEMU main page, I navigated to the download page. I downloaded using the command

wget http://wiki.qemu-project.org/download/qemu-2.7.0-rc2.tar.bz2

I unpacked the file using

tar xvjf qemu-2.7.0-rc2.tar.bz2

Changing directory as

cd qemu-2.7.0-rc2

I could then do the configuration, using the command

./configure --target-list=i386-softmmu,arm-softmmu,x86_64-softmmu --disable-vnc --enable-sdl

This, however, resulted in an error, as

qemu-2.7.0-rc2$ ./configure --target-list=i386-softmmu,arm-softmmu,x86_64-softmmu --disable-vnc --enable-sdl

ERROR: zlib check failed
Make sure to have the zlib libs and headers installed.

The zlib libs and headers were then installed, using the command

sudo apt-get install zlib1g-dev

Trying the configure command again resulted in

qemu-2.7.0-rc2$ ./configure --target-list=i386-softmmu,arm-softmmu,x86_64-softmmu --disable-vnc --enable-sdl

ERROR: User requested feature sdl
configure was not able to find it.
Install SDL devel

which was solved using the installation command

sudo apt-get install libsdl2-dev

Now the configure command went through!

But make failed!

qemu-2.7.0-rc2$ make
GEN i386-softmmu/config-devices.mak.tmp
GEN i386-softmmu/config-devices.mak
GEN arm-softmmu/config-devices.mak.tmp
GEN arm-softmmu/config-devices.mak
GEN x86_64-softmmu/config-devices.mak.tmp
GEN x86_64-softmmu/config-devices.mak
GEN config-all-devices.mak
GEN config-host.h
(cd /home/ola/qemu/qemu-2.7.0-rc2/pixman; autoreconf -v --install)
/bin/sh: 1: autoreconf: not found
Makefile:213: recipe for target '/home/ola/qemu/qemu-2.7.0-rc2/pixman/configure' failed
make: *** [/home/ola/qemu/qemu-2.7.0-rc2/pixman/configure] Error 127

So it was time for

sudo apt-get install autoconf

Here I remembered having used apt instead of apt-get, when I did an installation of another program, so I consulted this page about apt vs apt-get.

I tried

sudo apt install autoconf

which worked fine.

Running make now gave another error, as

qemu-2.7.0-rc2$ make
(cd /home/ola/qemu/qemu-2.7.0-rc2/pixman; autoreconf -v --install)
autoreconf: Entering directory `.'
autoreconf: configure.ac: not using Gettext
autoreconf: running: aclocal
autoreconf: configure.ac: tracing
autoreconf: configure.ac: not using Libtool
autoreconf: running: /usr/bin/autoconf
configure.ac:75: error: possibly undefined macro: AC_PROG_LIBTOOL
If this token and others are legitimate, please use m4_pattern_allow.
See the Autoconf documentation.
autoreconf: /usr/bin/autoconf failed with exit status: 1
Makefile:213: recipe for target '/home/ola/qemu/qemu-2.7.0-rc2/pixman/configure' failed
make: *** [/home/ola/qemu/qemu-2.7.0-rc2/pixman/configure] Error 1
make: *** Deleting file '/home/ola/qemu/qemu-2.7.0-rc2/pixman/configure'

which led me to install libtool, as

sudo apt install libtool

And now make started to build things – and it seemed to have succeeded!

I then did

sudo make install

which, since the configure command included x86 as well as ARM as targets, we should be able to run Linux for x86 and for ARM on our newly installed QEMU.

Doing some search, and looking at this page about booting a raw disk image in QEMU, led me to commands for obtaining and unpacking a Linux image for x86, as

cd ..
mkdir i386
cd i386/
wget http://wiki.qemu.org/download/linux-0.2.img.bz2
bunzip2 linux-0.2.img.bz2

QEMU could then be started, with this Linux image as the chosen software, as

qemu-system-i386 -drive format=raw,file=linux-0.2.img

For ARM, I did

cd ..
mkdir arm
cd arm
wget http://wiki.qemu.org/download/arm-test-0.2.tar.gz
tar zxvf arm-test-0.2.tar.gz

I could then run QEMU, with the downloaded ARM Linux as software, by doing

cd arm-test/
qemu-system-arm -machine integratorcp -kernel zImage.integrator -initrd arm_root.img -nographic -append "console=ttyAMA0"

For this example, I used Ctrl-A followed by x, to exit the QEMU simulation.

Installing QEMU on Mac OS X El Capitan

QEMU is an open source computer emulator. Here I describe how I installed QEMU on Mac OS X El Capitan.

My goal was to learn more about building QEMU, and to boot Linux on QEMU, and to check if there were differences in the installation compared to when doing it on Mac OS X Yosemite.

I downloaded and unpacked QEMU 2.5.0 (this was the latest stable release at the date I did the download), by doing

wget http://wiki.qemu-project.org/download/qemu-2.5.0.tar.bz2
tar xvjf qemu-2.5.0.tar.bz2
cd qemu-2.5.0

Then, based on my earlier experiences, I used the configure command

./configure --enable-cocoa --target-list=i386-softmmu,arm-softmmu,x86_64-softmmu --disable-vnc

and it succeeded! Here I took advantage of my previous installation of rudix, and the use of rudix for installing glib, which I did using the command

sudo rudix install glib

This installation of glib prevented an error printout

ERROR: glib-2.22 gthread-2.0 is required to compile QEMU

The next step is building, which I did by simply typing make, but that did not succeed.

There were warnings, but also errors. I searched using google, using the error printout as search terms. This led me to this page with advice, which told me to add make targets, resulting in lines like

region_test_OBJECTS = region-test.$(OBJEXT) utils.$(OBJEXT)

and

scaling_helpers_test_OBJECTS = scaling-helpers-test.$(OBJEXT) utils.$(OBJEXT)

in the file

./pixman/test/Makefile

where the targets utils.$(OBJEXT) were added by me.

The errors went away, resulting in a successful build. Again, I was helped by my earlier experiences, where I learned how to prevent link errors by installing gettext using rudix, as

sudo rudix install gettext

I could then do make install to install my new QEMU.

Now I wanted to boot Linux! I looked at the QEMU Testing page, and decided to download and unpack a Linux image for ARM by doing

wget http://wiki.qemu.org/download/arm-test-0.2.tar.gz
tar zxvf arm-test-0.2.tar.gz

A Linux boot could then be done, by starting QEMU with the downloaded Linux image as argument, as

cd arm-test
qemu-system-arm -machine integratorcp -kernel zImage.integrator -initrd arm_root.img -nographic -append "console=ttyAMA0"

When done, QEMU can be shut down by doing Ctrl-A x.