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 needs update (see comment from Patrik Lehmann below)

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:// 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

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

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
sudo make install
cd ../..

followed by the package mpfr, as

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
sudo make install
cd ../..

and finally, the third package mpc, as

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
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


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

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


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: not using Gettext
autoreconf: running: aclocal
autoreconf: tracing
autoreconf: not using Libtool
autoreconf: running: /usr/bin/autoconf 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/
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
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

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)


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

in the file


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

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.

Installing QEMU on Mac OS X Yosemite

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

My goal was to learn more about building QEMU, and to boot Linux on QEMU.

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

tar xvjf qemu-2.3.0.tar.bz2
cd qemu-2.3.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

This command generated an error, telling me that

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

I tried my previous approach, where I installed the required glib version using sudo port install. I used the command

sudo port install glib-2.2

which resulted in

Warning: port definitions are more than two weeks old, consider using selfupdate
Error: Port glib-2.2 not found

I followed this advice, and did

sudo port selfupdate

but that led me into new troubles, with error messages telling me that my Xcode Command Line Tools were most likely not installed. I tried to install these tools but without luck

I was about to give up when I stumbled upon rudix. This turned out to be an attractive solution! I read at the rudix page that I should do

sudo python install rudix

Then, from the rudix glib page, I learned that I should do

sudo rudix install glib

I did as told, and now the configure command

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

succeeded. I followed it up by building, using make, but that did not succeed.

I looked at the build errors, which led me to this page with advice, which told me to add make targets, resulting in lines like

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

in the file


where the last target had to be added by me. A similar change, in the same Makefile, was required, and resulted in the modified line

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

The errors went away, but a new link error remained. The error printout was

LINK qemu-ga
ld: library not found for -lintl
clang: error: linker command failed with exit code 1 (use -v to see invocation)
make: *** [qemu-ga] Error 1

I found this page with advice on how to solve it using brew (which was not applicable to my problem).

However, since I now had my rudix package, I chose instead to do

sudo rudix install gettext

This resulted in a successful build, and I could then also 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 by doing

bzip2 -d linux-0.2.img.bz2

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

qemu-system-i386 -hda linux-0.2.img

Into Embedded – two chapters to look at

The first two chapters of the book Into Embedded have been updated.

There is also a Book Software page where you can download the software for these two chapters.

The software treats, for 32-bit Intel and for ARM, the topic of building a small program that can run without the help of an operating system. This is often referred to as bare metal programming, and I think it can be both rewarding and challenging.

A bare-metal x86-cross-compiler on Mountain Lion

I wanted to create a bare-metal program for an Intel-x86 processor. The program is used in a chapter called The Bare Metal in the book Into Embedded.

On an Ubuntu Linux host I could use gcc, together with a linker script, to accomplish the task. I could then run the program using Bochs.

On a Mac Mountain Lion host, the above method did not work out of the box, due to ld not being the GNU linker.

In addition, gcc was not GNU gcc either.

I searched the net and found this interesting page by M3 Operating System Development where it was described how to build an i386 cross-compiler. I thought that this could be a way to create a compiler for bare-metal programs with no OS-dependencies – which was desirable since the bare-metal program was to be evolved into an OS by itself.

Problem arose, however, since the pre-installed gcc on my Mac could not build the i386-cross-gcc.

I searched again, and found this eminent page by Solarian Programmer where it is described how to build a GNU gcc compiler.

I downloaded the gcc 4.7.2 sources from the GNU ftp repository.

Then, following the instructions, however leaving out the choice of building a compiler for Fortran and also changing the gcc version from 4.7.1 to gcc 4.7.2, I was able to build a native GNU gcc compiler.

The newly built native gcc could then be set to the default gcc by issuing the command

export PATH=/usr/gcc-4.7.2/bin:$PATH

Then, returning to the instructions for building an i386-cross-gcc, I started with downloading


from the GNU binutils repository.

I created a destination directory for the cross compiler, by doing

sudo mkdir /usr/local/i386elfgcc/

The binutils could then be unpacked, configured, and built, using the commands

tar zxvf binutils-2.23.tar.gz
mkdir build-binutils
cd build-binutils/
../binutils-2.23/configure --target=i386-elf --prefix=/usr/local/i386elfgcc
sudo make install

I then built gcc, using inspiration also from this OS development wiki, by issuing the commands

tar xvjf gcc-4.7.2.tar.bz2
mkdir build-gcc
cd build-gcc
../gcc-4.7.2/configure --target=i386-elf --prefix=/usr/local/i386elfgcc --with-gnu-as --with-gnu-ld --disable-libssp --enable-languages=c --without-headers
make all-gcc
sudo make install-gcc

After having added /usr/local/i386elfgcc/bin to the PATH environment variable I was able to compile and link a bare metal program.

The program consists of three C-files, which I could compile using the commands

i386-elf-gcc -Wall -c screen_output.c
i386-elf-gcc -c -Wall -DBUILD_X86_FD_TARGET src/bare_metal.c -o obj/bare_metal_x86_fd_target.o
i386-elf-gcc -c -Wall -DBUILD_X86_FD_TARGET src/console.c -o obj/console_x86_fd_target.o

The program could then be linked, using a command where also startup code, written in assembly and assembled using NASM resulting in the object file start_code.o, as

i386-elf-ld -T arch/x86_fd_target/link.ld --oformat=elf32-i386 -melf_i386 arch/x86_fd_target/start_code.o arch/x86_fd_target/screen_output.o -o prog_x86_fd_target.elf obj/console_x86_fd_target.o obj/bare_metal_x86_fd_target.o

Finally, the file prog_x86_fd_target.elf needs to be converted from ELF format to raw binary format. This can be done using the command

i386-elf-objcopy -O binary prog_x86_fd_target.elf prog_x86_fd_target.bin

As a last step, a binary bootable image for a floppy-disc drive can be created, by concatenating a FAT12 boot sector, a defined number of empty FAT12-sectors, and the binary file created by the i386-elf-objcopy command.

The concatenation is done as

cat arch/x86_fd_target/boot.bin arch/x86_fd_target/b_32_512.bin prog_x86_fd_target.bin > arch/x86_fd_target/a.img

The program can now be run, using Bochs, by giving the command

bochs -f arch/x86_fd_target/bochsrc.txt -q