Running Linux, 5th Edition - Matthias Kalle Dalheimer [387]
Let's try out the makefile and see what it does:
papaya$ make edimh
gcc -c main.c
gcc -c edit.c
gcc -o edimh main.o edit.o
If we edit main.c and reissue the command, it rebuilds only the necessary files, saving us some time:
papaya$ make edimh
gcc -c main.c
gcc -o edimh main.o edit.o
It doesn't matter what order the three entries are within the makefile. make figures out which files depend on which and executes all the commands in the right order. Putting the entry for edimh first is convenient because that becomes the file built by default. In other words, typing make is the same as typing make edimh.
Here's a more extensive makefile. See if you can figure out what it does:
install: all
mv edimh /usr/local
mv readimh /usr/local
all: edimh readimh
readimh: read.o main.o
gcc -o readimh main.o read.o
edimh: main.o edit.o
gcc -o edimh main.o edit.o
main.o: main.c
gcc -c main.c
edit.o: edit.c
gcc -c edit.c
read.o: read.c
gcc -c read.c
First we see the target install. This is never going to generate a file; it's called a phony target because it exists just so that you can execute the commands listed under it. But before install runs, all has to run because install depends on all. (Remember, the order of the entries in the file doesn't matter.)
So make turns to the all target. There are no commands under it (this is perfectly legal), but it depends on edimh and readimh. These are real files; each is an executable program. So make keeps tracing back through the list of dependencies until it arrives at the .c files, which don't depend on anything else. Then it painstakingly rebuilds each target.
Here is a sample run (you may need root privilege to install the files in the /usr/local directory):
papaya$ make install
gcc -c main.c
gcc -c edit.c
gcc -o edimh main.o edit.o
gcc -c read.c
gcc -o readimh main.o read.o
mv edimh /usr/local
mv readimh /usr/local
This run of make does a complete build and install. First it builds the files needed to create edimh. Then it builds the additional object file it needs to create readmh. With those two executables created, the all target is satisfied. Now make can go on to build the install target, which means moving the two executables to their final home.
Many makefiles, including the ones that build Linux, contain a variety of phony targets to do routine activities. For instance, the makefile for the Linux kernel includes commands to remove temporary files:
clean: archclean
rm -f kernel/ksyms.lst
rm -f core `find . -name '*.[oas]' -print`
.
.
.
It also includes commands to create a list of object files and the header files they depend on (this is a complicated but important task; if a header file changes, you want to make sure the files that refer to it are recompiled):
depend dep:
touch tools/version.h
for i in init/*.c;do echo -n "init/";$(CPP) -M $$i;done > .tmpdep
.
.
.
Some of these shell commands get pretty complicated; we look at makefile commands later in this chapter, in "Multiple Commands."
Some Syntax Rules
The hardest thing about maintaining makefiles , at least if you're new to them, is getting the syntax right. OK, let's be straight about it: make syntax is really stupid. If you use spaces where you're supposed to use tabs or vice versa, your makefile blows up. And the error messages are really confusing. So remember the following syntax rules:
Always put a tab—not spaces—at the beginning of a command. And don't use a tab before any other line.
You can place a hash sign (#) anywhere on a line to start a comment. Everything after the hash sign is ignored.
If you put a backslash at the end of a line, it continues on the next line. That works for long commands and other types of makefile lines, too.
Now let's look at some of the powerful features of make, which form a kind of programming language of their own.