1.901
The ‘make’ Utility and Writing Makefiles

Introduction

What is Make?

make is a powerful and widely used build automation tool in software development, especially for C and C++, but also Java and many other programming languages. It is designed to help programmers manage complex projects by automating the process of building executable files, libraries, or other artifacts from source code. Make is particularly valuable when you have multiple source files, dependencies, and compilation steps in your project.

The make program is a standard utility for Unix/Linux and is also available on MacOS as part of xcode. For other platforms, there are many open source versions of make.

Interpreted languages such as Python or R do not require a facility similar to make. This tutorial focuses on GNU make which has become the standard. We will explain the key elements of building a “makefile” which are standard across most Linux systems (and MacOS). Many integrated development environments (such as Eclipse) use some version of a make facility although they often use XML to specify dependencies rather than a traditional makefile, often using the utility ant rather than make.

Why Use Make?

There are many reasons why make is so widely used. We will take a look at a few reasons below.

Dependency Management

One of the primary reasons for using make is its ability to manage dependencies efficiently. In a typical software project, you have source files that depend on each other, configuration files, libraries, and other resources. make tracks these dependencies and ensures that only the necessary parts of your project are rebuilt when something changes. This feature saves time and prevents unnecessary recompilation.

Automation

Make automates repetitive and error-prone tasks involved in the build process. Instead of manually typing out long compilation commands, linking steps, and other tasks, you define rules and let make handle the details. This not only reduces the chances of human error but also makes your build process consistent and reproducible.

Portability

make is platform-independent, which means you can use the same Makefile (the configuration file for make) on different operating systems. This portability makes it an attractive choice for cross-platform development.

Customization

Make is highly customizable. You can tailor your build process to suit your project’s specific requirements. Define variables, rules, and targets in your Makefile to accommodate different build configurations, development environments, or deployment platforms.

When to Use Make

You should consider using make when:

• You’re working on a project with multiple source files that need to be compiled and linked.
• You want to automate repetitive tasks such as building, testing, and cleaning your project.
• You need a tool that manages dependencies and ensures that only necessary parts of the project are rebuilt.
• Your project needs to be cross-platform, and you want a build system that works consistently on different operating systems.
• You value a high degree of customization and control over the build process.

In short, make is a fundamental tool for programmers and software developers. It streamlines the build process, manages dependencies, and automates tasks, ultimately leading to more efficient and maintainable software development projects. In the following sections of this tutorial, we will dive deeper into how to use make effectively to manage your projects.

Makefiles

Makefiles are an important element of programming, especially in C and C++ on Unix, although they can be found on other platforms and for other purposes as well. Essentially, makefiles are text files containing the rules on how an executable program is created from its source files and included libraries. A makefile serves as the input to the make program which read the rules in the makefile and produces an executable (well, a target, to be specific, which is most often an executable but doesn’t have to be). make applies the rules and only compiles what has changed since the last “build” of the executable. This is ideal when a project consists of many source files and a change in one would not require compiling all. Unfortunately, makefiles are a bit esoteric and the rules can be a bit baffling nowadays – after all, they were developed over fifty years ago when development tools were quite different.

Makefiles contain targets and dependency rules. If any source file’s dependencies change then the source file will get re-compiled and the new executable is linked.

A Simple Example

Running ‘make’

The ‘make’ command is run from the terminal (aka a shell).

% make target

When ‘make’ is run, it looks for a file named Makefile in the current folder. Note the capitalization of the file – it is important.

Let’s do the classic “Hello World” program as a makefile. Below is the contents of a really simple makefile (called Makefile).

hello:
    echo "Hello, World"

Important: Rules must be indented by a TAB and not spaces. So, hit the TAB key in your keyboard and do not type spaces with the spacebar on your keyboard. This is one of the most common mistakes that beginners run into.

Once you have the makefile, “execute it” by running the make program.

% make

Not specifying a target for make means that it builds the first target it finds.

Try it out for yourself

Go to the terminal, create a folder in which you can do this lesson, and use a text editor (e.g., vi) to create a file called Makefile and add the above.

Simple Build File Example

Makefiles are build files for projects and they contains all command to compile, link, copy, or move files and run scripts. Below is a simple example.

all: multithread

multithread: multithread.c
    gcc -o multithread multithread.c

Again, just as a reminder: the indent before gcc is a TAB and not spaces.

Generally makefiles contain a target named all that builds the entire project. It includes all of the sub targets, such as individual executables, test drivers, installation scripts, and so forth.

So, in the above example, all depends on multithread to be up-to-date, which, in turn, depends on multithread.c. So, if multithread.c changes, then it forces the rules to be applied and any commands below that rule are run. In the above example, that would be the compilation and linking with gcc.

To initiate the full build, call make all or simply make as all is the first target.

Makefile Structure and Syntax

A Makefile consists of a set of rules. A rule generally looks like this:

target: prerequisites
    command
    command
    command

The commands are the steps required to build the target. These need to start with a tab character and not spaces. The prerequisites are generally file names, separated by spaces. These files need to exist before the commands for the target are run. They define dependencies.

Target ‘clean’

Most makefiles includes a rule for a target named clean that is invoked with make clean. It’s purpose is to clean up your development environment remove the output of other targets. Note that is should not be the first target as it would then be the default target; the default target should be all.

Here is an example of a clean target for a simple project.

clean:
    rm -f multithread
    touch multithread.c

The rule removes the executable and updates the time stamp of last modification of the source file to the present time, which would force a recompile the next time you invoked make all.

Certainly, let’s expand on the second section, “Basic Makefile Structure,” to provide a more detailed explanation of the components of a Makefile and how they work together.

---

Basic Makefile Structure

A “Makefile” is a text file with the name Makefile (spelled just like that with a capital ‘M’) that contains instructions for the make utility on how to build a project. It consists of rules and targets, which are the building blocks of the Makefile. In this section, we will delve into the basic structure of a Makefile and explain how it works.

Rules and Targets

Targets

A target in a Makefile represents an output file or an action that make should perform. Targets are the goals of your build process, such as executables, object files, or other artifacts. Each target corresponds to a specific task that make can execute.

For example, in a C or C++ project, you might have targets like:

• my_program: To build the final executable.
• main.o, util.o: To compile individual source files into object files.
• clean: To remove generated files and clean up the project.

Rules

A rule defines how to create a target from its dependencies. It consists of a target, a colon (:), and a list of dependencies. Below the rule, you specify the commands needed to build the target from its dependencies. These commands are typically indented using tabs.

Here’s a basic rule structure:

target: dependencies
    [commands]

• Target: The name of the target you want to build.
• Dependencies: The files or targets that the current target depends on. These represent the prerequisites for building the target.
• Commands: The shell commands to be executed when make builds the target. These commands are indented with tabs.

Example Makefile

Let’s create a simple Makefile to compile a “Hello, World!” program written in C.

# Define the target and its dependencies
my_program: main.o

# Compile the program
main.o: main.c
    gcc -o main.o -c main.c

# Clean up generated files
clean:
    rm -f my_program main.o

In this Makefile:

• my_program is the target, and it depends on main.o.
• main.o is another target, which depends on main.c.
• The gcc command is used to compile main.c into an object file (main.o).
• The clean target is used to remove the generated files when you run make clean.

How make Works

When you run make in the command line without specifying a target, it looks for a special target called the default target. By convention, this is often named all. If you have an all target in your Makefile, make will execute the commands associated with that target.

For example:

all: my_program

When you run make without arguments, it will execute the all target, which depends on my_program. Thus, it will build my_program and its dependencies.

To summarize, a Makefile consists of rules and targets. Rules specify how to build targets from their dependencies. When you run make, it reads the Makefile, determines which targets need to be built or rebuilt based on file timestamps and dependencies, and then executes the corresponding commands. Understanding this basic structure is crucial for creating more complex and efficient Makefiles for your projects.

Certainly, let’s expand on the third section, “Makefile Rules and Targets,” to provide a more detailed explanation of rules, targets, and their practical usage in Makefiles.

---

3. Makefile Rules and Targets

In the context of make, rules and targets are fundamental concepts that define how your project’s build process works. Understanding how to structure and use them effectively in Makefiles is crucial for automating tasks and managing dependencies.

3.1 Targets

Targets in a Makefile represent the artifacts or actions that you want to create or perform. Targets are the focal points of your build process, and they can include:

• Executable programs.
• Object files (compiled source files).
• Documentation.
• Distribution packages.
• Custom tasks like cleaning or testing.

Each target corresponds to a specific task or output that make should generate. Targets can be created by defining their names in your Makefile.

3.1.1 Example Targets

In a C/C++ project, you might define targets like:

• my_program: To build the final executable.
• main.o, util.o: To compile individual source files into object files.
• clean: To remove generated files and clean up the project.

3.2 Rules

Rules in a Makefile define how to create a target from its dependencies. A rule consists of three main parts:

1. Target: The name of the target that you want to build.
2. Dependencies: The files or targets that the current target depends on. These represent the prerequisites for building the target.
3. Commands: The shell commands to be executed when make builds the target from its dependencies. These commands are typically indented with tabs.

3.2.1 Example Rule Structure

Here’s the structure of a rule:

target: dependencies
    [commands]

3.2.2 Example Rule

Consider a simple rule to compile a C source file into an object file:

main.o: main.c
    gcc -o main.o -c main.c

In this rule:

• main.o is the target we want to build.
• main.c is the dependency (source file) that main.o depends on.
• The command gcc -o main.o -c main.c is executed to build main.o from main.c.

3.3 Practical Usage

Makefiles become powerful when you have multiple rules and targets, and they help you automate complex build processes. Here are some practical tips:

3.3.1 Building All Targets

By convention, you can create an all target that depends on all the main targets in your project. When you run make, it builds the all target, which in turn builds everything else. For example:

all: my_program

my_program: main.o util.o
    gcc -o my_program main.o util.o

main.o: main.c
    gcc -o main.o -c main.c

util.o: util.c
    gcc -o util.o -c util.c

3.3.2 Cleaning Up

A clean target is handy for removing generated files and cleaning up your project. For example:

clean:
    rm -f my_program main.o util.o

3.3.3 Default Target

You can specify a default target by including it at the beginning of your Makefile. For example:

.DEFAULT_GOAL := all

This sets the all target as the default, so running make without any arguments will build all.

3.3.4 Phony Targets

Phony targets are targets that don’t represent actual files. They are used for tasks like cleaning, testing, or documentation generation. To declare a target as phony, use the .PHONY special target. For example:

.PHONY: clean test docs

clean:
    rm -f my_program main.o util.o

test:
    ./run_tests.sh

docs:
    doxygen

In this example, clean, test, and docs are phony targets.

3.4 Summary

In summary, Makefiles are composed of rules and targets. Rules specify how to build targets from their dependencies, and targets represent the artifacts or actions you want to create or perform. Understanding the structure and usage of rules and targets is essential for effectively automating tasks and managing dependencies in your software projects.

Certainly, let’s expand on the fourth section, “Variables in Makefiles,” to provide a more detailed explanation of variables and their practical usage in Makefiles.

---

4. Variables in Makefiles

Variables play a crucial role in Makefiles by allowing you to define reusable values that can be used throughout the file. They enhance the readability, maintainability, and flexibility of your Makefiles. In this section, we will explore how to declare and use variables effectively.

4.1 Declaring Variables

In a Makefile, you can declare variables using the following syntax:

VARIABLE_NAME = value

• VARIABLE_NAME: This is the name of the variable, which should be written in uppercase letters by convention.
• value: This is the value assigned to the variable. It can be a string, a command, or another variable.

4.2 Using Variables

You can use variables by enclosing their names in $(...) or ${...}. For example:

CC = gcc
CFLAGS = -Wall -O2

my_program: main.c
    $(CC) $(CFLAGS) -o my_program main.c

In this example, CC and CFLAGS are variables, and their values are substituted when the my_program target is built.

4.3 Variable Types

4.3.1 Simple Variables

Simple variables are defined using = as shown above. They can be overridden if redefined later in the Makefile.

4.3.2 Recursive Variables

Recursive variables are defined using :=. They are evaluated only when used, which means changes to their values do not affect previous usages.

VAR := initial_value
VAR := new_value  # Does not affect previous usages of VAR

4.3.3 Conditional Variables

Conditional variables are defined using ?=. They are set only if the variable is not already defined. This is useful for providing default values.

VAR ?= default_value  # VAR is set to default_value if VAR is not already defined

4.4 Practical Usage

Variables are beneficial in Makefiles for various reasons:

4.4.1 Compiler and Flags

You can use variables to store the compiler and compilation flags, making it easy to change them globally in your Makefile:

CC = gcc
CFLAGS = -Wall -O2

my_program: main.c
    $(CC) $(CFLAGS) -o my_program main.c

4.4.2 File Lists

Variables are useful for defining lists of files, especially when there are many source files:

SOURCES = main.c util.c
OBJECTS = $(SOURCES:.c=.o)

my_program: $(OBJECTS)
    $(CC) $(CFLAGS) -o my_program $(OBJECTS)

Here, OBJECTS is generated from SOURCES, converting .c to .o.

4.4.3 Conditional Compilation

Variables enable conditional compilation based on build configurations or target platforms:

# Build a debug version when DEBUG is defined
ifdef DEBUG
    CFLAGS += -g
endif

my_program: main.c
    $(CC) $(CFLAGS) -o my_program main.c

4.4.4 Versioning

You can define version numbers or project information as variables for easy updates:

VERSION = 1.0
PROJECT_NAME = my_project

my_program: main.c
    $(CC) $(CFLAGS) -o $(PROJECT_NAME)_$(VERSION) main.c

4.5 Conclusion

Variables in Makefiles provide flexibility and maintainability. They allow you to define values once and use them throughout your Makefile, making it easier to manage build configurations and adapt to different scenarios. Using variables effectively can simplify the maintenance of complex projects and make your Makefiles more readable.

Certainly, let’s expand on the fifth section, “Automatic Variables,” to provide a more detailed explanation of automatic variables and their practical usage in Makefiles.

---

5. Automatic Variables in Makefiles

Automatic variables are a set of predefined variables in Makefiles that simplify the construction of rules by providing information about the target and dependencies being processed. They help avoid redundancy in your Makefile and make it more concise. In this section, we’ll explore common automatic variables and how to use them effectively.

5.1 Common Automatic Variables

5.1.1 $@ - The Target

$@ represents the target of the rule being executed. It’s particularly useful when you have multiple rules with similar patterns, as it allows you to reference the target without repeating its name.

Example:

my_program: main.o util.o
    $(CC) $(CFLAGS) -o $@ $^

Here, $@ is replaced with my_program, and $^ with main.o util.o.

5.1.2 $^ - All Dependencies

$^ represents all the dependencies of the rule being executed. This is handy when you want to include all prerequisites in a command.

5.1.3 $< - The First Dependency

$< stands for the first dependency in the list of prerequisites. It’s often used when there’s only one dependency and you want to reference it directly.

Example:

main.o: main.c
    $(CC) $(CFLAGS) -o $@ $<

Here, $< is replaced with main.c.

5.1.4 $? - Out-of-Date Dependencies

$? represents all the dependencies that are out-of-date concerning the target. It’s useful when you want to process only the files that have changed since the last build.

5.2 Practical Usage

Automatic variables simplify Makefile rules, making them more concise and less error-prone. Here are some practical examples of how to use them:

5.2.1 Building Multiple Targets

Automatic variables are especially useful when building multiple targets from a single rule:

objects = main.o util.o

all: my_program

my_program: $(objects)
    $(CC) $(CFLAGS) -o $@ $^

$(objects): %.o: %.c
    $(CC) $(CFLAGS) -c -o $@ $<

In this example, $@ and $^ are used to specify the target and dependencies for the my_program rule, as well as for the pattern rule that compiles .c files into .o files.

5.2.2 Conditional Compilation

Automatic variables can be used to simplify conditional compilation based on build configurations or target platforms:

DEBUG ?= 0

ifeq ($(DEBUG), 1)
    CFLAGS += -g
endif

my_program: main.c
    $(CC) $(CFLAGS) -o $@ $<

Here, $< represents the first dependency, which is main.c. If DEBUG is defined as 1, the -g flag is added to the compilation command.

5.2.3 Out-of-Date Dependencies

Automatic variables like $? are useful when you want to process only the dependencies that have changed since the last build. For example, in a custom build script:

generate_resources: resource_generator
    ./resource_generator -o $@ $?

resource_generator: resource_generator.c
    $(CC) $(CFLAGS) -o $@ $<

In this example, generate_resources depends on the resource_generator program and all the out-of-date resource files ($?) to generate new resources.

5.3 Conclusion

Automatic variables in Makefiles simplify rule construction and reduce redundancy in your build scripts. By using variables like $@, $^, $<, and $?, you can create more concise and maintainable Makefiles that adapt to changes in your project without the need for extensive manual editing. Understanding and utilizing these automatic variables effectively can significantly enhance your Makefile-writing skills.

Certainly, let’s expand on the sixth section, “Phony Targets,” to provide a more detailed explanation of phony targets and their practical usage in Makefiles.

---

6. Phony Targets in Makefiles

In Makefiles, phony targets are targets that don’t represent files or artifacts but rather serve as labels for specific actions or tasks that need to be executed. Phony targets are essential for tasks such as cleaning, testing, or generating documentation. In this section, we will explore what phony targets are and how to use them effectively.

6.1 What Are Phony Targets?

Phony targets are used to define actions or tasks that make should perform when explicitly requested, but they don’t correspond to actual files in the file system. They are declared in a Makefile to provide convenient names for common development and maintenance tasks, allowing you to execute these tasks using the make command.

Typically, phony targets have no prerequisites or dependencies because their purpose is to execute a specific action, not to build a file based on dependencies.

6.2 Declaring Phony Targets

To declare a target as phony, you use the .PHONY special target in your Makefile, followed by a list of phony target names. For example:

.PHONY: clean test docs

In this example, we’ve declared three phony targets: clean, test, and docs. These targets represent common development tasks such as cleaning up generated files, running tests, and generating documentation.

6.3 Practical Usage

Phony targets are valuable for automating various development and maintenance tasks. Here are some common use cases and practical examples of phony targets:

6.3.1 Cleaning

A clean phony target is used to remove generated files and artifacts to ensure a clean project directory. It’s especially important when you want to rebuild your project from scratch or before archiving or distributing it.

.PHONY: clean

clean:
    rm -f my_program main.o util.o

Running make clean will remove the executable my_program and the object files (main.o and util.o) from the project directory.

6.3.2 Testing

A test phony target is used to run your project’s test suite. This is especially helpful for continuous integration (CI) workflows.

.PHONY: test

test:
    ./run_tests.sh

Here, run_tests.sh is a script that executes your project’s test cases. Running make test will trigger this script and execute the tests.

6.3.3 Generating Documentation

A docs phony target is used to generate project documentation. For example, if you use Doxygen for documentation generation:

.PHONY: docs

docs:
    doxygen

Running make docs will generate documentation using Doxygen or any other documentation generation tool you prefer.

6.3.4 Dependency Analysis

You can use phony targets to analyze dependencies in your project, such as generating dependency files for C/C++ code. For instance, using the GCC -M flag to generate dependency files:

.PHONY: depend

depend:
    gcc -M *.c > dependencies

Running make depend will update the dependencies file with the latest dependency information for your project.

6.4 Conclusion

Phony targets in Makefiles provide a way to define and automate common development and maintenance tasks. By declaring phony targets, you can use the make command to execute these tasks conveniently without worrying about file dependencies. This helps streamline your development workflow, making it easier to clean, test, and document your projects efficiently.

Certainly, let’s expand on the seventh section, “Dependency Management,” to provide a more detailed explanation of how dependency management works in Makefiles and its practical usage.

---

7. Dependency Management in Makefiles

Dependency management is a critical aspect of Makefiles, as it ensures that make rebuilds only those targets that are out-of-date based on changes in their dependencies. In this section, we will delve deeper into how dependency management works and provide practical examples.

7.1 Defining Dependencies

In a Makefile, dependencies are specified in the rules for each target. A target depends on one or more files or other targets, known as prerequisites. When make encounters a rule, it checks if the target is older than any of its prerequisites. If a prerequisite is newer than the target or if the target doesn’t exist, make rebuilds the target.

Here’s the basic structure of a rule with dependencies:

target: dependencies
    [commands]

7.2 How make Determines What to Build

When you run make, it follows these steps to determine what needs to be built:

1. It reads the Makefile to build a dependency graph that shows how targets and dependencies are related.
2. It checks the timestamps of targets and their dependencies.
3. If a target is older than any of its dependencies, or if the target doesn’t exist, make executes the commands associated with that target to rebuild it.
4. It recursively builds any prerequisites that are out-of-date before building the target.

7.3 Practical Usage

Let’s look at practical examples of how dependency management works in Makefiles.

7.3.1 C/C++ Compilation

Consider a simple C/C++ project with multiple source files and header files:

CC = gcc
CFLAGS = -Wall -O2

my_program: main.o util.o
    $(CC) $(CFLAGS) -o my_program main.o util.o

main.o: main.c util.h
    $(CC) $(CFLAGS) -c -o main.o main.c

util.o: util.c util.h
    $(CC) $(CFLAGS) -c -o util.o util.c

In this example:

• my_program depends on main.o and util.o.
• main.o depends on main.c and util.h.
• util.o depends on util.c and util.h.

If you modify main.c or util.c, running make will rebuild only the affected object files and then re-link the program. The dependencies ensure that only the necessary parts of the project are rebuilt.

7.3.2 Automatic Dependency Generation

Make can also generate dependency information automatically using tools like gcc -M. For example:

CC = gcc
CFLAGS = -Wall -O2

SOURCES = main.c util.c
OBJECTS = $(SOURCES:.c=.o)

my_program: $(OBJECTS)
    $(CC) $(CFLAGS) -o my_program $(OBJECTS)

%.o: %.c
    $(CC) $(CFLAGS) -c -o $@ $<

# Automatically generate dependencies
%.d: %.c
    $(CC) -M -MP -MF $@ -MT $(@:.d=.o) $<

In this example, the %.d rule generates dependency files (*.d) that contain information about the header file dependencies of each source file. These dependency files are then included in the Makefile, ensuring that changes in header files trigger recompilation.

To include the generated dependency files in your Makefile, add this line:

-include $(SOURCES:.c=.d)

This line tells make to include the generated .d files.

7.4 Conclusion

Dependency management is a fundamental aspect of Makefiles, enabling efficient and automated builds. By specifying dependencies for each target, you can ensure that make rebuilds only what is necessary, reducing build times and ensuring consistency in your projects. Understanding how dependency management works and how to use it effectively is essential for efficient software development workflows.

Certainly, let’s expand on the eighth section, “Conditional Statements in Makefiles,” to provide a more detailed explanation of conditional statements and their practical usage in Makefiles.

---

8. Conditional Statements in Makefiles

Conditional statements in Makefiles allow you to create rules and targets that vary depending on specific conditions or variables. These statements enable you to customize your build process, adapt to different environments, or handle various build configurations. In this section, we’ll explore the use of conditional statements in Makefiles and provide practical examples.

8.1 Conditional Directives

Makefiles use conditional directives to define rules, targets, and variables based on conditions. Common conditional directives include ifeq, ifneq, ifdef, and ifndef. These directives allow you to check for equality, inequality, or variable existence.

The basic structure of conditional directives is as follows:

conditional_directive
    # Condition
    [commands]
else
    # Alternative commands
endif

8.2 Practical Usage

Let’s explore some practical examples of how conditional statements can be used in Makefiles.

8.2.1 Conditional Compilation

Conditional compilation is a common use case for conditional statements in Makefiles. You can use conditionals to include or exclude specific source files or compiler flags based on build configurations.

DEBUG ?= 0

ifeq ($(DEBUG), 1)
    CFLAGS += -g
endif

my_program: main.c
    $(CC) $(CFLAGS) -o my_program main.c

In this example, the -g flag is added to CFLAGS if the DEBUG variable is set to 1. This allows you to control whether debugging information is included in the compiled binary.

8.2.2 Platform-Specific Rules

You can use conditionals to define platform-specific rules or variables. For instance, you might have different compilation settings for Windows and Linux:

UNAME_S := $(shell uname -s)

ifeq ($(UNAME_S),Linux)
    CC = gcc
    CFLAGS = -Wall -O2
endif

ifeq ($(UNAME_S),Windows_NT)
    CC = cl
    CFLAGS = /W4 /O2
endif

my_program: main.c
    $(CC) $(CFLAGS) -o my_program main.c

Here, the Makefile sets the compiler (CC) and compiler flags (CFLAGS) based on the host operating system.

8.2.3 Variable Assignment

Conditional statements can also be used for variable assignment. For example, you might want to set a variable differently depending on whether a specific tool is available:

ifdef TOOL_EXISTS
    COMPILER = $(TOOL_EXISTS)
else
    COMPILER = gcc
endif

my_program: main.c
    $(COMPILER) -o my_program main.c

In this case, if the TOOL_EXISTS variable is defined, it will be used as the compiler; otherwise, gcc is used as the default.

8.3 Nested Conditionals

You can nest conditional statements to handle more complex scenarios:

DEBUG ?= 0
TARGET ?= linux

ifeq ($(DEBUG), 1)
    CFLAGS += -g
else
    ifeq ($(TARGET), windows)
        CFLAGS += -O2
    else
        CFLAGS += -O3
    endif
endif

my_program: main.c
    $(CC) $(CFLAGS) -o my_program main.c

In this example, the build configuration depends on both the DEBUG variable and the TARGET variable. Depending on these conditions, different optimization flags (-g, -O2, or -O3) are used.

8.4 Conclusion

Conditional statements in Makefiles provide flexibility and adaptability to your build process. They allow you to customize rules, targets, and variables based on conditions, making your Makefiles more versatile and suitable for various build scenarios. Understanding how to use conditional statements effectively can help you manage complex projects and accommodate different environments and configurations.

Certainly, let’s expand on the ninth section, “Pattern Rules and Automatic Prerequisites,” to provide a more detailed explanation of pattern rules, automatic prerequisites, and their practical usage in Makefiles.

---

9. Pattern Rules and Automatic Prerequisites in Makefiles

Pattern rules are a powerful feature in Makefiles that allow you to define generic rules for building multiple targets with similar patterns. Automatic prerequisites extend this concept by automatically generating dependency information for source files. In this section, we will explore how to use pattern rules and automatic prerequisites effectively in Makefiles.

9.1 Pattern Rules

Pattern rules in Makefiles define a general rule for building targets that match a specific pattern. They are a way to avoid writing multiple similar rules for targets with a common structure. The syntax for a pattern rule is:

%.out: %.c
    [commands]

• %.out: The target pattern that matches any target ending with .out.
• %.c: The prerequisite pattern that matches any source file ending with .c.
• [commands]: The commands to build the target from the prerequisite.

For example, if you have multiple C source files and want to create executables from them, you can use a pattern rule like this:

%.out: %.c
    gcc -o $@ $<

Now, make can build any target with a .out extension from the corresponding .c source file.

9.2 Automatic Prerequisites

Automatic prerequisites are an extension of pattern rules that automatically generate dependency information for source files. This is particularly useful when you want to track changes in header files and automatically rebuild targets when header files change.

To enable automatic prerequisites, you can use the -M flag with the gcc or g++ compiler to generate dependency information. For example:

%.o: %.c
    gcc -MMD -MP -MF $*.d -c -o $@ $<

• -MMD: Generate dependency information.
• -MP: Generate phony targets for missing headers.
• -MF $*.d: Specify the dependency file to be generated (e.g., main.d for main.c).
• -c -o $@ $<: Compile the source file into an object file.

Additionally, you can include the generated dependency files in your Makefile to ensure accurate tracking of header file changes:

-include $(wildcard *.d)

This line tells make to include all .d files in the current directory.

9.3 Practical Usage

Let’s look at practical examples of how pattern rules and automatic prerequisites can be used in Makefiles.

9.3.1 Building Multiple Targets

Pattern rules are excellent for building multiple targets from similar source files. Suppose you have several C source files (file1.c, file2.c, etc.) that you want to compile into executables (file1.out, file2.out, etc.). You can use the following pattern rule:

%.out: %.c
    gcc -o $@ $<

Now, make file1.out will compile file1.c into file1.out, and the same rule applies to other source files.

9.3.2 Automatic Prerequisites for C/C++ Projects

Automatic prerequisites simplify dependency tracking in C/C++ projects. Consider this Makefile for a C project:

CC = gcc
CFLAGS = -Wall -O2

SOURCES = main.c util.c
OBJECTS = $(SOURCES:.c=.o)

-include $(wildcard *.d)

%.o: %.c
    $(CC) -MMD -MP -MF $*.d $(CFLAGS) -c -o $@ $<

my_program: $(OBJECTS)
    $(CC) $(CFLAGS) -o my_program $(OBJECTS)

With this setup, the Makefile automatically generates dependency files (.d) for each source file and includes them. If a header file changes, only the affected source files are rebuilt, saving compilation time.

9.3.3 Generic Rules for Build Systems

Pattern rules are especially useful in build systems that need to handle various source files and targets. For example, in a build system for a scripting language interpreter:

%.o: %.c
    $(CC) -MMD -MP -MF $*.d $(CFLAGS) -c -o $@ $<

interpreter: $(OBJECTS)
    $(CC) $(CFLAGS) -o interpreter $(OBJECTS)

This pattern rule and target allow you to compile any .c source file into an object file and then link them to create the interpreter.

9.4 Conclusion

Pattern rules and automatic prerequisites in Makefiles provide a powerful way to streamline the build process for projects with multiple source files and dependencies. By defining generic rules for building targets and automatically generating dependency information, you can save time and ensure accurate tracking of changes in source files and headers. Understanding how to use pattern rules and automatic prerequisites effectively is essential for efficient software development workflows.

Certainly, let’s expand on the tenth section, “Managing Libraries and Linking,” to provide a more detailed explanation of how to manage libraries and linking in Makefiles.

---

10. Managing Libraries and Linking in Makefiles

Libraries are an essential part of software development, and in Makefiles, managing libraries and linking them to your programs is crucial. In this section, we will explore how to include and link libraries effectively in Makefiles.

10.1 Including Libraries

Including libraries in your Makefile involves specifying the necessary libraries that your program depends on. You typically use the -l flag followed by the library name when invoking the linker (e.g., gcc or g++).

Here’s an example of how to include the math library in a Makefile:

my_program: main.c
    gcc -o my_program main.c -lm

In this example, the -lm flag tells the linker to include the math library.

10.2 Specifying Library Directories

Sometimes, the libraries you need may be located in non-standard directories. You can specify library directories using the -L flag and then include the libraries using the -l flag.

my_program: main.c
    gcc -o my_program main.c -L/path/to/libdir -lmylib

In this case, /path/to/libdir is the directory containing the libmylib.a or libmylib.so library file.

10.3 Practical Usage

Let’s explore some practical examples of managing libraries and linking them in Makefiles.

10.3.1 Linking with Multiple Libraries

If your program depends on multiple libraries, you can specify them by separating them with space after the -l flag:

my_program: main.c
    gcc -o my_program main.c -lm -lpthread -lmylib

In this example, we’re linking with the math library (-lm), the pthread library (-lpthread), and a custom library (-lmylib).

10.3.2 Using Variables for Libraries

To make your Makefile more maintainable, you can use variables to store library flags:

LIBS = -lm -lpthread -lmylib

my_program: main.c
    gcc -o my_program main.c $(LIBS)

By using variables, it’s easier to add or remove libraries from your project without changing every occurrence in your Makefile.

10.3.3 Conditional Linking

You can use conditional statements in your Makefile to handle different build configurations and link libraries accordingly. For example, you might want to link with a debugging library when debugging is enabled:

DEBUG ?= 0
LIBS = -lm -lpthread

ifeq ($(DEBUG), 1)
    LIBS += -ldebug
endif

my_program: main.c
    gcc -o my_program main.c $(LIBS)

In this example, the -ldebug library is included in the LIBS variable only if the DEBUG variable is set to 1.

10.3.4 Automatic Dependency Tracking

If your project has header file dependencies, you can use automatic prerequisites (as discussed in section 9) to automatically track changes in header files and recompile the program when needed. This ensures that your program is rebuilt when any of its dependencies change.

CC = gcc
CFLAGS = -Wall -O2
SOURCES = main.c util.c
OBJECTS = $(SOURCES:.c=.o)

-include $(wildcard *.d)

%.o: %.c
    $(CC) -MMD -MP -MF $*.d $(CFLAGS) -c -o $@ $<

my_program: $(OBJECTS)
    $(CC) $(CFLAGS) -o my_program $(OBJECTS) -lm -lpthread -lmylib

In this example, we include libraries as well as dependencies generated for source files.

10.4 Conclusion

Managing libraries and linking in Makefiles is essential for building complex software projects. By specifying libraries, library directories, and using variables and conditional statements, you can create Makefiles that handle library management efficiently. Additionally, automatic dependency tracking ensures that your program is rebuilt when necessary, keeping your build process up-to-date and reliable. Understanding these concepts is crucial for effective software development workflows using Makefiles.

Certainly, let’s expand on the eleventh section, “Cleaning and Maintenance,” to provide a more detailed explanation of cleaning targets, maintaining Makefiles, and other aspects related to cleaning and maintaining your project with Makefiles.

---

11. Cleaning and Maintenance in Makefiles

Cleaning and maintaining a project is a crucial part of software development. Makefiles provide several features to help you manage these tasks efficiently. In this section, we will explore how to create cleaning targets, handle project maintenance, and other related aspects in Makefiles.

11.1 Cleaning Targets

Cleaning targets are used to remove generated files and artifacts, ensuring a clean project directory for rebuilding or distribution. A common cleaning target in a Makefile is clean. To create a clean target, you can use the following rule:

.PHONY: clean

clean:
    rm -f my_program *.o

In this example, the clean target removes the my_program executable and all object files (*.o) from the project directory when you run make clean.

11.2 Maintenance Targets

Maintenance targets are used to perform tasks related to project maintenance, such as generating documentation, running tests, or checking code formatting. Here are some examples:

11.2.1 Generating Documentation

You can create a target called docs to generate project documentation. For instance, if you use Doxygen for documentation generation:

.PHONY: docs

docs:
    doxygen

Running make docs will execute the doxygen command to generate documentation.

11.2.2 Running Tests

To run your project’s test suite, you can create a target called test:

.PHONY: test

test:
    ./run_tests.sh

In this example, the test target executes a script (run_tests.sh) that runs your project’s test cases.

11.2.3 Code Formatting

You can also create a target to check or format your code using tools like clang-format:

.PHONY: format

format:
    clang-format -i *.c

Running make format would apply code formatting to all .c source files.

11.3 Automating Dependency Cleanup

If your Makefile generates dependency files (as discussed in section 9), you can create a target to clean up these files when no longer needed:

.PHONY: clean-deps

clean-deps:
    rm -f *.d

The clean-deps target removes all generated dependency files (*.d) from the project directory.

11.4 Conditional Maintenance Targets

You can use conditional statements to control when maintenance targets should be executed. For example, you might want to generate documentation only for specific build configurations:

DEBUG ?= 0

ifeq ($(DEBUG), 1)
    .PHONY: docs

    docs:
        doxygen
endif

In this example, the docs target is defined and marked as phony only if the DEBUG variable is set to 1, ensuring that documentation is generated only for debugging builds.

11.5 Conclusion

Cleaning and maintaining a project are essential aspects of software development, and Makefiles offer convenient ways to automate these tasks. By creating cleaning and maintenance targets, you can keep your project directory organized and up-to-date. Additionally, using conditional statements allows you to control when these targets are executed, ensuring they align with your project’s needs and build configurations. Understanding and effectively utilizing these features in Makefiles is crucial for managing complex software projects efficiently.

Certainly, let’s expand on the twelfth section, “Advanced Techniques and Best Practices,” to provide a more detailed explanation of advanced Makefile techniques and best practices that can help you create efficient and maintainable build systems.

Advanced Techniques and Best Practices in Makefiles

Advanced techniques and best practices in Makefiles can significantly improve the efficiency and maintainability of your build system. In this section, we’ll explore some advanced techniques and best practices that can elevate your Makefile skills.

Use Variables for Compiler and Flags

Using variables to store compiler and flag settings in your Makefile makes it more maintainable and adaptable. For example:

CC = gcc
CFLAGS = -Wall -O2

By defining these variables, you can easily change the compiler or compiler flags in one place, making it less error-prone and more flexible.

Phony Targets

Always mark targets that don’t correspond to actual files (e.g., clean, all, test, docs) as phony using the .PHONY special target. This helps prevent conflicts with files of the same name and ensures that the target is always executed, even if a file with the same name exists.

.PHONY: clean test docs

Use Wildcards for Source Files

Instead of listing all source files manually, you can use wildcards to automatically detect source files in a directory. For example, to compile all .c files in the current directory:

SOURCES = $(wildcard *.c)

This approach is more maintainable as it automatically adapts to changes in the directory.

Generating Dependency Files Automatically

Automatically generating dependency files for C/C++ projects using tools like gcc -M (as discussed in section 9) is a powerful technique. It ensures that your Makefile accurately tracks header file dependencies, reducing the risk of broken builds.

-include $(wildcard *.d)

Conditional Compilation

Conditional compilation (as discussed in section 8) allows you to adapt your build process to different configurations or platforms. This can be useful for enabling or disabling features, setting compiler flags conditionally, or specifying different build paths.

Separate Directories for Object Files

Organizing object files in a separate directory (e.g., obj/) instead of cluttering the source directory can make your project structure cleaner and avoid conflicts between object files and source files with the same names.

OBJ_DIR = obj
OBJECTS = $(addprefix $(OBJ_DIR)/, $(SOURCES:.c=.o))

$(OBJ_DIR)/%.o: %.c
    $(CC) -MMD -MP -MF $(OBJ_DIR)/$*.d $(CFLAGS) -c -o $@ $<

Target-Specific Variables

You can set variables that are specific to a particular target. This allows you to customize compilation flags or settings for specific source files or targets.

my_program: main.c
    $(CC) $(CFLAGS) -o my_program main.c

special_target: special.c
    $(CC) $(CFLAGS_SPECIAL) -o special_target special.c

Here, CFLAGS_SPECIAL is used only for the special_target.

Parallel Builds

You can use the -j flag with the make command to enable parallel builds, which can significantly reduce build times on multi-core systems. For example, make -j4 will run up to four jobs concurrently.

Comments and Documentation

Adding comments to your Makefile helps document its structure and purpose. It’s also a good practice to include a section at the beginning of your Makefile that explains its usage, dependencies, and any special instructions for building the project.

Version Control Integration

If you’re using a version control system like Git, consider adding a .gitignore file to ignore generated files, object files, and build artifacts. This keeps your repository clean and avoids tracking unnecessary files.

Continuous Integration

Integrate your Makefile with a continuous integration (CI) system like Jenkins, Travis CI, or GitHub Actions. This ensures that your project is automatically built and tested on every push to the repository, helping catch issues early.

Debugging Makefiles

When debugging Makefiles, you can use the -n or --just-print flag with make to see the commands that would be executed without actually running them. This can help identify issues in your rules and dependencies. A common mistake is not starting a line for a command with the TAB or using an editor which replaces TAB with 4 or 8 spaces.

Testing and Validation

Regularly test and validate your Makefiles with various build configurations and platforms to ensure they work correctly in different scenarios. Automated testing of the build process can be invaluable in catching regressions.

Modularization

For complex projects, consider modularizing your Makefile by splitting it into multiple smaller Makefiles or including separate Makefiles for specific components or subsystems. This can make the build system more manageable.

Performance Optimization

Profile and optimize your build process, especially for large projects. Identifying and eliminating bottlenecks can significantly improve build times and developer productivity.

Build Targets

Define clear and specific build targets (e.g., all, clean, test, docs, install) to standardize the build process across your projects and make it easier for team members to understand and use the Makefile.

Error Handling

Implement error handling in your Makefile to detect and report errors during the build process. You can use constructs like || to execute commands conditionally based on the success of previous commands.

Continuous Learning

Keep exploring advanced Makefile techniques, best practices, and new features as you continue to work on different projects. Makefiles are a versatile tool, and there’s always more to learn.

Conclusion

Advanced techniques and best practices in Makefiles can significantly enhance the efficiency, reliability, and maintainability of your build systems. By applying these practices, you can create robust and adaptable Makefiles that streamline the development and deployment of your software projects. Continuously improving your Makefile skills is a valuable asset in software development.

Summary

In this tutorial on make for programmers, we covered a wide range of topics to help you understand and effectively use Makefiles in your software development projects. Here’s a summary of the key points covered in the sections:

2. Basic Makefile Structure: The fundamental structure of a Makefile, including rules, targets, and commands.

3. Target Rules and Dependencies: How to define targets and their dependencies, ensuring that Make knows when to rebuild a target.

4. Implicit Rules and Variables: Implicit rules that Make uses by default and how to override them using variables.

5. User-Defined Variables: How to define your own variables in Makefiles to make them more flexible and maintainable.

6. Phony Targets: The concept of phony targets for defining actions or tasks that don’t produce files, and their practical usage.

7. Dependency Management: How Make manages dependencies and automatically rebuilds targets when dependencies change.

8. Conditional Statements: Using conditional statements to create rules and targets that adapt to different conditions or configurations.

9. Pattern Rules and Automatic Prerequisites: How to use pattern rules to build targets with similar patterns and automatically generate dependency information.

10. Managing Libraries and Linking: Including libraries in your Makefile, specifying library directories, and handling advanced linking.

11. Cleaning and Maintenance: Creating cleaning and maintenance targets, handling project maintenance, and automating dependency cleanup.

12. Advanced Techniques and Best Practices: Advanced techniques and best practices for more efficient and maintainable Makefiles, including using variables, phony targets, wildcards, and version control integration.

By understanding and applying the concepts and techniques discussed in this tutorial, you can create robust and efficient Makefiles to automate your build processes, manage dependencies, and maintain your software projects effectively. Makefiles are a valuable tool in the arsenal of any developer, helping to streamline the development workflow and ensure consistent, reliable builds.

Tutorial

None yet.

Files & Resources

All Files for Lesson 1.901

---

References

Learn Makefiles

Errata

Let us know.