Scribd
Upload
24 views

Unix Makefiles

The document discusses Unix makefiles and how the "make" utility works. It explains that makefiles contain directives that tell make how to compile a program by specifying dependencies between files. Make only compiles files that have changed or ones that depend on changed files, allowing developers to efficiently rebuild a program without recompiling all files. The key components of a makefile include rules, dependency lines, shell lines, macros, comments, and inference rules.

Uploaded by

Gauri Virkar
Copyright
© © All Rights Reserved
Available Formats
Download as PPT, PDF, TXT or read online on Scribd
24 views

Unix Makefiles

The document discusses Unix makefiles and how the "make" utility works. It explains that makefiles contain directives that tell make how to compile a program by specifying dependencies between files. Make only compiles files that have changed or ones that depend on changed files, allowing developers to efficiently rebuild a program without recompiling all files. The key components of a makefile include rules, dependency lines, shell lines, macros, comments, and inference rules.

Uploaded by

Gauri Virkar
Copyright
© © All Rights Reserved
Available Formats
Download as PPT, PDF, TXT or read online on Scribd
You are on page 1/ 21

Unix Makefiles

Introduction
• The “make” utility in Unix is one of the original tools designed
by S. I. Fieldman of AT&T Bell labs circa 1977. There are many
version.

• What is “make”?: The tool is designed to allow programmers


to efficiently compile large complex programs with many
components easily.

• You can place the commands to compile a program in a Unix


script but this will cause ALL modules to be compiled every
time.

• The “make” utility allows us to only compile those that have


changed and the modules that depend upon them.
How Does it Work?
• In Unix, when you type the command “make” the operating
system looks for a file called either “makefile” or “Makefile”.

• This file contains a series of directives that tell the “make”


utility how to compile your program and in what order.

• Each file will be associated with a list of other files by which it


is dependent. This is called a dependency line.

• If any of the associated files have been recently modified, the


make utility will execute a directive command just below the
dependency line.
sum (exe)

main.o sum.o

main.c sum.h sum.c sum.h


makefile

sum: main.o sum.o


gcc –o sum main.o sum.o

main.o: main.c sum.h


gcc –c main.c

sum.o: sum.c sum.h


gcc –c sum.c
Make operation - example

File Last Modified


sum 10:03
main.o 09:56
sum.o 09:35
main.c 10:45
sum.c 09:14
sum.h 08:39
Make operation - example

• Operations performed:
gcc –c main.c
gcc –o sum main.o sum.o
• main.o should be recompiled (main.c is
newer).
• Consequently, main.o is newer than sum
and therefore sum should be recreated (by
re-linking).
Components of a Makefile
• Comments
• Rules
• Dependency Lines
• Shell Lines
• Macros
• Inference Rules
Comments
• A comment is indicated by the character “#”. All text that
appears after it will be ignored by the make utility until the
end of line is detected.

• Comments can start anywhere.

• Example
– #
– # This is a comment
Rules
• Rules tell make when and how to make a file. The format is as
follows:
– A rule must have a dependency line and may have an action or shell
line after it. The action line is executed if the dependency line is out
of date.

– Example:
hello.o: hello.cpp
g++ -c hello.cpp

– This shows hello.o as a module that requires hello.cpp as source


code. If the last modified date of hello.cpp is newer than hello.o,
than the next line (shell line) is executed.

– Together, these two lines form a rule.


Rule syntax

main.o: main.c sum.h


Rule
gcc –c main.c

tab

dependency action
makefile

sum: main.o sum.o


gcc –o sum main.o sum.o

main.o: main.c sum.h


gcc –c main.c

sum.o: sum.c sum.h


gcc –c sum.c
Dependency Lines
• The lines with a “:” are called dependency lines.
– To the left are the dependencies (or target)
– To the right are the sources needed to make the
dependency.

• At the running of the make utility, the time and date when
sum.exe was last built are compared to the dates when
main.obj and sum.obj were built.

• If either main.obj or sum.obj have new dates, then the shell


line after the dependency line is executed.
Shell Lines
• The indented lines (must have tab) that follow each
dependency line are called shell lines. Shell lines tell
make how to build the target.

• A target can have more than one shell line. Each line
must be preceded by a tab.

• After each shell is executed, make checks to see if it


was completed without error.
Shell Lines
• After each shell line is executed, Make checks the shell line’s
exit status.

• Shell lines that returning an exit status of zero (0) means


without error and non-zero if there is an error.

• The first shell line that returns an exit status of non-zero will
cause the make utility to stop and display an error.
Macros
• Comes from the Greek word makros meaning large.

• Basically it is a shorthand or alias used in the


makefile

• A string is associated with another usually larger


string

• Inside the file, to expand a macro, you have to place


the string inside of $( ) .

• The whole thing is expanded during execution of the


make utility.
Macros
• Macros are defined in a Makefile as = pairs.
• For example,
• MACROS = -me
• PSROFF = groff –Tps
• DITROFF = groff -Tdvi
• CFLAGS = -O -systype bsd43
• LIBS = "-lncurses -lm -lsdl"
• MYFACE = ":*)"
Macro
• There are certain special macros predefined −
$@ is the name of the file to be made.
$? is the names of the changed dependents.

1. CC Program for compiling C programs; default


is `cc'.
2. CO Program for checking out files from RCS;
default is `co'.
3. CXX Program for compiling C++ programs;
default is `g++'.
4. CFLAGS Extra flags to give to the C compiler.

5. LDFLAGS Extra flags to give to compilers when they


are supposed to invoke the linker, `ld'.
Example of Macro
For example, we could use a rule as follows

hello: main.cpp hello.cpp factorial.cpp


$(CC) $(CFLAGS) $? $(LDFLAGS) -o $@

#[gcc main.cpp hello.cpp factorial.cpp -o hello]


Inference Rules
• Inference rules are a method of generalizing the
build process. In essence, it is a sort of wild card
notation.

• The “%” is used to indicate a wild card.

• Examples:
• %.obj : %.c
• $(CC) $(FLAGS) –c $(.SOURCE)

• All .obj files have dependencies of all %.c files of the


same name.
MAKE OPERATION
• Project dependencies tree is constructed

• Target of first rule should be created

• We go down the tree to see if there is a target that should


be recreated. This is the case when the target file is older
than one of its dependencies

• In this case we recreate the target file according to the


action specified, on our way up the tree. Consequently,
more files may need to be recreated.

• make operation ensures minimum compilation, when the


project structure is written properly

You might also like