If you are starting from a source distribution, and just want a completely standard build, then the following procedure should work (unless you're on Windows, in which case go to Section 13, “Instructions for building under Windows”).

$ autoreconf
$ ./configure
$ make
$ make install

For GHC, this will do a 2-stage bootstrap build of the compiler, with profiling libraries, and install the results.

If you want to do anything at all non-standard, or you want to do some development, read on...

The source code is held in your source tree. The root directory of your source tree must contain the following directories and files:

All the other directories are individual projects of the fptools system—for example, the Glasgow Haskell Compiler (ghc), the Happy parser generator (happy), the nofib benchmark suite, and so on. You can have zero or more of these. Needless to say, some of them are needed to build others.

The important thing to remember is that even if you want only one project (happy, say), you must have a source tree whose root directory contains Makefile, mk/, configure.ac, and the project(s) you want (happy/ in this case). You cannot get by with just the happy/ directory.

If you just want to build the software once on a single platform, then your source tree can also be your build tree, and you can skip the rest of this section.

We often want to build multiple versions of our software for different architectures, or with different options (e.g. profiling). It's very desirable to share a single copy of the source code among all these builds.

So for every source tree we have zero or more build trees. Each build tree is initially an exact copy of the source tree, except that each file is a symbolic link to the source file, rather than being a copy of the source file. There are “standard” Unix utilities that make such copies, so standard that they go by different names: lndir, mkshadowdir are two (If you don't have either, the source distribution includes sources for the X11 lndir—check out fptools/glafp-utils/lndir). See Section 7.5, “The story so far” for a typical invocation.

The build tree does not need to be anywhere near the source tree in the file system. Indeed, one advantage of separating the build tree from the source is that the build tree can be placed in a non-backed-up partition, saving your systems support people from backing up untold megabytes of easily-regenerated, and rapidly-changing, gubbins. The golden rule is that (with a single exception—Section 7.4, “Getting the build you want”) absolutely everything in the build tree is either a symbolic link to the source tree, or else is mechanically generated. It should be perfectly OK for your build tree to vanish overnight; an hour or two compiling and you're on the road again.

You need to be a bit careful, though, that any new files you create (if you do any development work) are in the source tree, not a build tree!

Remember, that the source files in the build tree are symbolic links to the files in the source tree. (The build tree soon accumulates lots of built files like Foo.o, as well.) You can delete a source file from the build tree without affecting the source tree (though it's an odd thing to do). On the other hand, if you edit a source file from the build tree, you'll edit the source-tree file directly. (You can set up Emacs so that if you edit a source file from the build tree, Emacs will silently create an edited copy of the source file in the build tree, leaving the source file unchanged; but the danger is that you think you've edited the source file whereas actually all you've done is edit the build-tree copy. More commonly you do want to edit the source file.)

Like the source tree, the top level of your build tree must be (a linked copy of) the root directory of the fptools suite. Inside Makefiles, the root of your build tree is called $(FPTOOLS_TOP). In the rest of this document path names are relative to $(FPTOOLS_TOP) unless otherwise stated. For example, the file ghc/mk/target.mk is actually $(FPTOOLS_TOP)/ghc/mk/target.mk.

When you build fptools you will be compiling code on a particular host platform, to run on a particular target platform (usually the same as the host platform). The difficulty is that there are minor differences between different platforms; minor, but enough that the code needs to be a bit different for each. There are some big differences too: for a different architecture we need to build GHC with a different native-code generator.

There are also knobs you can turn to control how the fptools software is built. For example, you might want to build GHC optimised (so that it runs fast) or unoptimised (so that you can compile it fast after you've modified it. Or, you might want to compile it with debugging on (so that extra consistency-checking code gets included) or off. And so on.

All of this stuff is called the configuration of your build. You set the configuration using a three-step process.

And that's it for configuration. Simple, eh?

What do you put in your build-specific configuration file mk/build.mk? For almost all purposes all you will do is put make variable definitions that override those in mk/config.mk.in. The whole point of mk/config.mk.in—and its derived counterpart mk/config.mk—is to define the build configuration. It is heavily commented, as you will see if you look at it. So generally, what you do is look at mk/config.mk.in, and add definitions in mk/build.mk that override any of the config.mk definitions that you want to change. (The override occurs because the main boilerplate file, mk/boilerplate.mk, includes build.mk after config.mk.)

For your convenience, there's a file called build.mk.sample that can serve as a starting point for your build.mk.

For example, config.mk.in contains the definition:

GhcHcOpts=-O -Rghc-timing

The accompanying comment explains that this is the list of flags passed to GHC when building GHC itself. For doing development, it is wise to add -DDEBUG, to enable debugging code. So you would add the following to build.mk:

or, if you prefer,

GhcHcOpts += -DDEBUG

GNU make allows existing definitions to have new text appended using the “+=” operator, which is quite a convenient feature.)

If you want to remove the -O as well (a good idea when developing, because the turn-around cycle gets a lot quicker), you can just override GhcLibHcOpts altogether:

GhcHcOpts=-DDEBUG -Rghc-timing

When reading config.mk.in, remember that anything between “@...@” signs is going to be substituted by configure later. You can override the resulting definition if you want, but you need to be a bit surer what you are doing. For example, there's a line that says:

TAR = @TarCmd@

This defines the Make variables TAR to the pathname for a tar that configure finds somewhere. If you have your own pet tar you want to use instead, that's fine. Just add this line to mk/build.mk:

TAR = mytar

You do not have to have a mk/build.mk file at all; if you don't, you'll get all the default settings from mk/config.mk.in.

You can also use build.mk to override anything that configure got wrong. One place where this happens often is with the definition of FPTOOLS_TOP_ABS: this variable is supposed to be the canonical path to the top of your source tree, but if your system uses an automounter then the correct directory is hard to find automatically. If you find that configure has got it wrong, just put the correct definition in build.mk.

Let's summarise the steps you need to carry to get yourself a fully-configured build tree from scratch.

You can make subsequent changes to mk/build.mk as often as you like. You do not have to run any further configuration programs to make these changes take effect. In theory you should, however, say gmake clean, gmake all, because configuration option changes could affect anything—but in practice you are likely to know what's affected.

At this point you have made yourself a fully-configured build tree, so you are ready to start building real things.

The first thing you need to know is that you must use GNU make, usually called gmake, not standard Unix make. If you use standard Unix make you will get all sorts of error messages (but no damage) because the fptools Makefiles use GNU make's facilities extensively.

To just build the whole thing, cd to the top of your fptools tree and type gmake. This will prepare the tree and build the various projects in the correct order.

GHC requires a 2-stage bootstrap in order to provide full functionality, including GHCi. By a 2-stage bootstrap, we mean that the compiler is built once using the installed GHC, and then again using the compiler built in the first stage. You can also build a stage 3 compiler, but this normally isn't necessary except to verify that the stage 2 compiler is working properly.

Note that when doing a bootstrap, the stage 1 compiler must be built, followed by the runtime system and libraries, and then the stage 2 compiler. The correct ordering is implemented by the top-level fptools Makefile, so if you want everything to work automatically it's best to start make from the top of the tree. When building GHC, the top-level fptools Makefile is set up to do a 2-stage bootstrap by default (when you say make). Some other targets it supports are:

The top-level Makefile also arranges to do the appropriate make boot steps (see below) before actually building anything.

The stage1, stage2 and stage3 targets also work in the ghc/compiler directory, but don't forget that each stage requires its own make boot step: for example, you must do

$ make boot stage=2

before make stage2 in ghc/compiler.

In any directory you should be able to make the following:

All of these standard targets automatically recurse into sub-directories. Certain other standard targets do not:

Most Makefiles have targets other than these. You can discover them by looking in the Makefile itself.

If you want to build GHC (say) and just use it direct from the build tree without doing make install first, you can run the in-place driver script: ghc/compiler/ghc-inplace.

Do NOT use ghc/compiler/ghc, or ghc/compiler/ghc-6.xx, as these are the scripts intended for installation, and contain hard-wired paths to the installed libraries, rather than the libraries in the build tree.

Happy can similarly be run from the build tree, using happy/src/happy-inplace, and similarly for Alex and Haddock.

Sometimes the dependencies get in the way: if you've made a small change to one file, and you're absolutely sure that it won't affect anything else, but you know that make is going to rebuild everything anyway, the following hack may be useful:

$ gmake FAST=YES

This tells the make system to ignore dependencies and just build what you tell it to. In other words, it's equivalent to temporarily removing the .depend file in the current directory (where mkdependHS and friends store their dependency information).

A bit of history: GHC used to come with a fastmake script that did the above job, but GNU make provides the features we need to do it without resorting to a script. Also, we've found that fastmaking is less useful since the advent of GHC's recompilation checker (see the User's Guide section on "Separate Compilation").