GNU Make

https://www.gnu.org/software/make/manual/
Admin
GNU Make is a utility that automatically builds executable programs and libraries from source code...
Tokens:271,300
Snippets:1,879
Trust Score:10
Update:1 week ago
Show doc for...
Tokens:
Raw
### Makefile: Define installation directory variables

Source: https://www.gnu.org/software/make/manual/html_node/Directory-Variables.html

Example makefile fragment showing common prefix and directory variables, including bindir, libexecdir, and infodir. The prefix directory must exist before install.

```makefile
# Common prefix for installation directories.
# NOTE: This directory must exist when you start the install.
prefix = /usr/local
datarootdir = $(prefix)/share
datadir = $(datarootdir)
exec_prefix = $(prefix)
# Where to put the executable for the command 'gcc'.
bindir = $(exec_prefix)/bin
# Where to put the directories used by the compiler.
libexecdir = $(exec_prefix)/libexec
# Where to put the Info files.
infodir = $(datarootdir)/info

```

--------------------------------

### Installation target

Source: https://www.gnu.org/software/make/manual/html_node/Complex-Makefile.html

Installs the built tar binary, optionally installs rmt, and installs info files. Uses $(INSTALL) and $(INSTALLDATA) variables.

```makefile
.PHONY: install
install: all
        $(INSTALL) tar $(bindir)/$(binprefix)tar
        -test ! -f rmt || $(INSTALL) rmt /etc/rmt
        $(INSTALLDATA) $(srcdir)/tar.info* $(infodir)

```

--------------------------------

### Example Makefile with multiple targets and rules

Source: https://www.gnu.org/software/make/manual/make.txt

A complete example Makefile from the GNU Make manual showing typical targets like all, install, clean, dist, and others, along with dependency rules and shell commands. It demonstrates the use of .PHONY targets, automatic variables, and shell scripting within make rules.

```makefile
.PHONY: all
all:    tar rmt tar.info

tar:    $(OBJS)
        $(CC) $(LDFLAGS) -o $@ $(OBJS) $(LIBS)

rmt:    rmt.c
        $(CC) $(CFLAGS) $(LDFLAGS) -o $@ rmt.c

tar.info: tar.texinfo
        makeinfo tar.texinfo

.PHONY: install
install: all
        $(INSTALL) tar $(bindir)/$(binprefix)tar
        -test ! -f rmt || $(INSTALL) rmt /etc/rmt
        $(INSTALLDATA) $(srcdir)/tar.info* $(infodir)

$(OBJS): tar.h port.h testpad.h
regex.o buffer.o tar.o: regex.h
# getdate.y has 8 shift/reduce conflicts.

testpad.h: testpad
        ./testpad

testpad: testpad.o
        $(CC) -o $@ testpad.o

TAGS:   $(SRCS)
        etags $(SRCS)

.PHONY: clean
clean:
        rm -f *.o tar rmt testpad testpad.h core

.PHONY: distclean
distclean: clean
        rm -f TAGS Makefile config.status

.PHONY: realclean
realclean: distclean
        rm -f tar.info*

.PHONY: shar
shar: $(SRCS) $(AUX)
        shar $(SRCS) $(AUX) | compress \
          > tar-`sed -e '/version_string/!d' \
                     -e 's/[^0-9.]*\([0-9.]*\).*/\1/' \
                     -e q
                     version.c`.shar.Z

.PHONY: dist
dist: $(SRCS) $(AUX)
        echo tar-`sed \
             -e '/version_string/!d' \
             -e 's/[^0-9.]*\([0-9.]*\).*/\1/' \
             -e q
             version.c` > .fname
        -rm -rf `cat .fname`
        mkdir `cat .fname`
        ln $(SRCS) $(AUX) `cat .fname`
        tar chZf `cat .fname`.tar.Z `cat .fname`
        -rm -rf `cat .fname` .fname

tar.zoo: $(SRCS) $(AUX)
        -rm -rf tmp.dir
        -mkdir tmp.dir
        -rm tar.zoo
        for X in $(SRCS) $(AUX) ; do \
            echo $$X ; \
            sed 's/$$/^M/' $$X \
            > tmp.dir/$$X ; done
        cd tmp.dir ; zoo aM ../tar.zoo *
        -rm -rf tmp.dir
```

--------------------------------

### Using DESTDIR for staged installs

Source: https://www.gnu.org/software/make/manual/make.txt

Shows how to prepend DESTDIR to installed target files for staged installs.

```make
$(INSTALL_PROGRAM) foo $(DESTDIR)$(bindir)/foo
$(INSTALL_DATA) libfoo.a $(DESTDIR)$(libdir)/libfoo.a
```

--------------------------------

### Invoking make with DESTDIR

Source: https://www.gnu.org/software/make/manual/html_node/DESTDIR.html

Example of specifying DESTDIR on the make command line for a staged install. This would install files under /tmp/stage instead of the normal locations.

```shell
make DESTDIR=/tmp/stage install

```

--------------------------------

### addprefix function example

Source: https://www.gnu.org/software/make/manual/html_node/File-Name-Functions.html

Prepends a prefix to each name in the list. Example produces 'src/foo src/bar'.

```makefile
$(addprefix src/,foo bar)
```

--------------------------------

### Install multiple files in one command

Source: https://www.gnu.org/software/make/manual/html_node/Command-Variables.html

Shows an acceptable way to install multiple files in one command, with the final argument being a directory.

```makefile
$(INSTALL_PROGRAM) foo bar baz $(bindir)

```

--------------------------------

### install-strip target using install with INSTALL_PROGRAM

Source: https://www.gnu.org/software/make/manual/html_node/Standard-Targets.html

Shows a simple way to implement the install-strip target by invoking the install target with INSTALL_PROGRAM set to include the -s flag. This works only when the package installs executables but not scripts.

```makefile
install-strip:
        $(MAKE) INSTALL_PROGRAM='$(INSTALL_PROGRAM) -s' \
                install

```

--------------------------------

### Create installation directories with DESTDIR support

Source: https://www.gnu.org/software/make/manual/html_node/Standard-Targets.html

Makefile rule to create installation directories using mkinstalldirs, with support for DESTDIR (strongly encouraged). This rule should only create directories, not modify compilation directories.

```makefile
# Make sure all installation directories (e.g. $(bindir))
# actually exist by making them if necessary.
installdirs: mkinstalldirs
        $(srcdir)/mkinstalldirs \
            $(DESTDIR)$(bindir) $(DESTDIR)$(datadir) \
            $(DESTDIR)$(libdir) $(DESTDIR)$(infodir) \
            $(DESTDIR)$(mandir)

```

--------------------------------

### Create installation directories with mkinstalldirs

Source: https://www.gnu.org/software/make/manual/html_node/Standard-Targets.html

Makefile rule to create installation directories using the mkinstalldirs script. The script is available in the Gnulib package. This rule should only create directories, not modify compilation directories.

```makefile
# Make sure all installation directories (e.g. $(bindir))
# actually exist by making them if necessary.
installdirs: mkinstalldirs
        $(srcdir)/mkinstalldirs $(bindir) $(datadir) \
                                $(libdir) $(infodir) \
                                $(mandir)

```

--------------------------------

### Sample rule to install an Info file (do-install-info)

Source: https://www.gnu.org/software/make/manual/html_node/Standard-Targets.html

A Makefile rule that installs an Info file, preferring the one in the current directory over srcdir, and runs install-info only if it exists. It uses $(NORMAL_INSTALL) and $(POST_INSTALL) command categories, and checks for install-info with '$(SHELL) -c' to avoid failures on systems without it.

```makefile
do-install-info: foo.info installdirs
        $(NORMAL_INSTALL)
# Prefer an info file in . to one in srcdir.
        if test -f foo.info; then d=.; \
         else d="$(srcdir)"; fi; \
        $(INSTALL_DATA) $$d/foo.info \
          "$(DESTDIR)$(infodir)/foo.info"
# Run install-info only if it exists.
# Use 'if' instead of just prepending '-' to the
# line so we notice real errors from install-info.
# Use '$(SHELL) -c' because some shells do not
# fail gracefully when there is an unknown command.
        $(POST_INSTALL)
        if $(SHELL) -c 'install-info --version' \
           >/dev/null 2>&1; then \
          install-info --dir-file="$(DESTDIR)$(infodir)/dir" \
                       "$(DESTDIR)$(infodir)/foo.info"; \
        else true; fi

```

--------------------------------

### Example of -l option with load average limit

Source: https://www.gnu.org/software/make/manual/html_node/Parallel.html

Shows the -l option followed by a floating-point number to limit the number of jobs based on load average. In this example, make will not start more than one job if the load average is above 2.5.

```make
-l 2.5

```

--------------------------------

### word function example

Source: https://www.gnu.org/software/make/manual/html_node/Text-Functions.html

Returns the nth word of text, with n starting from 1. If n exceeds the word count, the result is empty.

```makefile
$(word 2, foo bar baz)
```

--------------------------------

### System Configuration Section

Source: https://www.gnu.org/software/make/manual/html_node/Complex-Makefile.html

This section sets the shell and source directory, followed by compiler and installation tool definitions. It includes comments about using gcc with -traditional option to avoid ioctl issues.

```makefile
SHELL = /bin/sh

#### Start of system configuration section. ####

srcdir = .

# If you use gcc, you should either run the
# fixincludes script that comes with it or else use
# gcc with the -traditional option.  Otherwise ioctl
# calls will be compiled incorrectly on some systems.
CC = gcc -O
YACC = bison -y
INSTALL = /usr/local/bin/install -c
INSTALLDATA = /usr/local/bin/install -c -m 644
```

--------------------------------

### Basic .ONESHELL example with cd and gobble

Source: https://www.gnu.org/software/make/manual/html_node/One-Shell.html

Shows a makefile using .ONESHELL so that the cd and gobble commands run in a single shell invocation, preserving newlines between recipe lines.

```makefile
.ONESHELL:
foo : bar/lose
        cd $(<D)
        gobble $(<F) > ../$@

```

--------------------------------

### Allowed programs for pre/post-installation commands

Source: https://www.gnu.org/software/make/manual/html_node/Install-Command-Categories.html

Pre-installation and post-installation commands should not run any programs except these. This list is a constraint on what can be used.

```text
[ basename bash cat chgrp chmod chown cmp cp dd diff echo
expand expr false find getopt grep gunzip gzip
hostname install install-info kill ldconfig ln ls md5sum
mkdir mkfifo mknod mv printenv pwd rm rmdir sed sort tee
test touch true uname xargs yes

```

--------------------------------

### Prepending DESTDIR to install commands

Source: https://www.gnu.org/software/make/manual/html_node/DESTDIR.html

Shows how to prepend $(DESTDIR) to each installed target file in install targets. The variable is specified by the user on the make command line as an absolute file name.

```makefile
$(INSTALL_PROGRAM) foo $(DESTDIR)$(bindir)/foo
$(INSTALL_DATA) libfoo.a $(DESTDIR)$(libdir)/libfoo.a

```

--------------------------------

### Pattern rule example: %.o : %.c

Source: https://www.gnu.org/software/make/manual/html_node/Pattern-Intro.html

Shows a pattern rule that builds a .o file from a corresponding .c file, using the '%' wildcard to match the stem. The recipe is not shown, only the rule header.

```makefile
%.o : %.c ; recipe…
```

--------------------------------

### addsuffix function example

Source: https://www.gnu.org/software/make/manual/html_node/File-Name-Functions.html

Appends a suffix to each name in the list. Example produces 'foo.c bar.c'.

```makefile
$(addsuffix .c,foo bar)
```

--------------------------------

### findstring function examples

Source: https://www.gnu.org/software/make/manual/html_node/Text-Functions.html

Searches for a substring; returns the find string if found, otherwise empty. The examples produce 'a' and '' respectively.

```make
$(findstring a,a b c)
```

```make
$(findstring a,b c)
```

--------------------------------

### Typical subdirectory recipe using simply expanded variables

Source: https://www.gnu.org/software/make/manual/html_node/Simple-Assignment.html

Shows a typical recipe for descending into subdirectories, using the simply expanded MAKE variable to pass host-type and whoami.

```makefile
${subdirs}:
        ${MAKE} -C $@ all

```

--------------------------------

### Recipe using file function with foreach for line-per-argument

Source: https://www.gnu.org/software/make/manual/html_node/File-Function.html

Example recipe that writes each object on a separate line using `$(file >$@.in)` to create the file and `$(foreach O,$^,$(file >>$@.in,$O))` to append each argument. The file is then passed to the command and removed.

```makefile
program: $(OBJECTS)
        $(file >$@.in) $(foreach O,$^,$(file >>$@.in,$O))
        $(CMD) $(CMDFLAGS) @$@.in
        @rm $@.in

```

--------------------------------

### filter function example

Source: https://www.gnu.org/software/make/manual/html_node/Text-Functions.html

Returns words matching any pattern. The example shows a makefile rule where only .c and .s files are passed to the compiler.

```make
sources := foo.c bar.c baz.s ugh.h
foo: $(sources)
        cc $(filter %.c %.s,$(sources)) -o foo
```

--------------------------------

### join function example

Source: https://www.gnu.org/software/make/manual/html_node/File-Name-Functions.html

Concatenates two lists word by word. Example '$(join a b,.c .o)' produces 'a.c b.o'.

```makefile
$(join a b,.c .o)
```

--------------------------------

### pre-install.awk script to filter pre-install commands

Source: https://www.gnu.org/software/make/manual/make.txt

Awk script that prints lines between 'pre-install' and 'normal-install' or 'post-install' markers. Used with the make command above to extract pre-installation commands.

```awk
$0 ~ /^(normal-install|post-install)[ \t]*$/ {on = 0}
on {print $0}
$0 ~ /^pre-install[ \t]*$/ {on = 1}
```

--------------------------------

### basename function example

Source: https://www.gnu.org/software/make/manual/html_node/File-Name-Functions.html

Extracts all but the suffix of each file name. Periods in the directory part are ignored. Example produces 'src/foo src-1.0/bar hacks'.

```makefile
$(basename src/foo.c src-1.0/bar hacks)
```

--------------------------------

### Object files to source files substitution example

Source: https://www.gnu.org/software/make/manual/html_node/Text-Functions.html

Given a list of object files, $(objects:.o=.c) produces the corresponding source files, equivalent to $(patsubst %.o,%.c,$(objects)).

```make
objects = foo.o bar.o baz.o
```

```make
$(objects:.o=.c)
```

```make
$(patsubst %.o,%.c,$(objects))
```

--------------------------------

### suffix function example

Source: https://www.gnu.org/software/make/manual/html_node/File-Name-Functions.html

Extracts the suffix (from the last period) of each file name. If no period, suffix is empty. Example produces '.c .c'.

```makefile
$(suffix src/foo.c src-1.0/bar.c hacks)
```

--------------------------------

### Example of specifying DESTDIR on the make command line

Source: https://www.gnu.org/software/make/manual/make.txt

Shows how the user specifies DESTDIR as an absolute file name on the make command line.

```make
make DESTDIR=/tmp/stage install
```

--------------------------------

### Simple foreach Example with wildcard

Source: https://www.gnu.org/software/make/manual/html_node/Foreach-Function.html

Sets `files` to all files in directories a, b, c, d. The `foreach` expands `$(wildcard $(dir)/*)` for each directory, concatenating results with spaces.

```makefile
dirs := a b c d
files := $(foreach dir,$(dirs),$(wildcard $(dir)/*))

```
Tokens:
Raw