Phony targets, pattern rules, implicit rules

5.3.7 · Coding › Build Systems & Toolchain

Intuition Badi tasveer

Make ek dependency engine hai: tum isse batate ho kya exist karna chahiye aur kya us par depend karta hai, aur yeh timestamps compare karke khud figure out karta hai ki kya rebuild karna hai. Lekin teen features is rule ko toda-modata hai:

Phony targets — "kaam" jo files NAHI hain (clean, all, test). Yeh timestamps ki parwah kiye bina hamesha run hone chahiye.
Pattern rules — ek template jaise %.o: %.c jo kai files build karta hai, taaki tum apne aap ko repeat na karo.
Implicit rules — built-in templates jo Make pehle se jaanta hai, taaki foo.o bina koi rule likhe bhi foo.c se build ho sake.

YEH KYUN EXIST KARTE HAIN: 100 .c files wale Makefile mein 100 lagbhag identical rules ki zaroorat padti. Yeh teen features us sab ko kuch lines mein compress kar dete hain aur non-file goals ke liye timestamp logic ko theek karte hain.

1. Core model (scratch se derive karo)

KAYA hai ek rule — atomic unit:

target: prerequisites
	recipe       # MUST be a TAB, not spaces

KAISE Make decide karta hai recipe run karne ko:

TIMESTAMPS KYUN, content nahi? Kyunki timestamp check karna $O (1)$ hai — ek stat() call — jabki file contents ko hash karna $O (size)$ hai. Make clock-skew-correctness ki jagah speed leta hai. Yeh akela faisla sab kuch niche drive karta hai.

2. Phony targets

.PHONY KYUN CHAHIYE: socho teri directory mein accidentally clean naam ki ek file exist karti hai.

clean:
	rm -f *.o

.PHONY ke bina, Make file clean dekhta hai, paata hai uske koi prerequisites nahi hain, decide karta hai woh up to date hai (timestamp model: missing? nahi. kisi prereq se purani? koi prereqs nahi hain), aur print karta hai make: 'clean' is up to date. — recipe kabhi nahi chalti. Yahi bug hai.

Fix — Make ko batao ki yeh target hamesha out of date hai:

.PHONY: clean all test
 
all: program
 
clean:
	rm -f *.o program
 
test: program
	./program --selftest

3. Pattern rules

Canonical wala:

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

Step by step % kya karta hai, jab Make ko parser.o chahiye:

Make ko parser.o chahiye. Koi explicit rule nahi? Pattern rules search karo.
%.o matches karta hai parser.o ke saath stem = parser. Yeh step kyun? % greedily woh sab bind karta hai jo literal parts (.o) ko align kare.
Stem ko prereq %.c mein substitute karo → parser.c. Kyun? Stem dono taraf identical hona chahiye — isi tarah Make target ko source se link karta hai.
Agar parser.c exist karta hai (ya khud banaaya ja sakta hai), toh rule apply hota hai.

Automatic variables (inhe cold yaad karo):

Var	Matlab	Hamare `parser.o` rule mein
`$@`	target	`parser.o`
`$<`	pehla prerequisite	`parser.c`
`$^`	saare prerequisites (deduped)	`parser.c parser.h …`
`$*`	stem	`parser`

AUTOMATIC VARIABLES KYUN EXIST KARTE HAIN: pattern abhi concrete names nahi jaanta, isliye Make unhe match time par inject karta hai. Tum rule ek baar likho, generically.

Figure — Phony targets, pattern rules, implicit rules

4. Implicit rules

KYUN: 90% C/C++ projects .c → .o usi tarah compile karte hain, isliye GNU Make isse hard-code karta hai:

# built-in, roughly:
%.o: %.c
	$(CC) $(CPPFLAGS) $(CFLAGS) -c $< -o $@

Toh yeh poora Makefile kaam karta hai:

program: main.o util.o
	$(CC) $^ -o $@
# koi %.o rule nahi likha — implicit rule main.o aur util.o build karta hai!

Tum implicit rules ko built-in variables ke zariye influence karte ho: CC, CFLAGS, CPPFLAGS, LDFLAGS. Yahi hai 80/20: woh variables set karo, implicit machinery ko kaam karne do.

5. Worked examples

Worked example Example A — poora mini project

CC      := gcc
CFLAGS  := -Wall -O2
OBJ     := main.o math.o
 
.PHONY: all clean
all: calc
 
calc: $(OBJ)
	$(CC) $(LDFLAGS) $^ -o $@      # $^ = main.o math.o
 
%.o: %.c
	$(CC) $(CFLAGS) -c $< -o $@    # $< = the .c, $@ = the .o
 
clean:
	rm -f $(OBJ) calc

make ka trace:

Default goal all → calc chahiye. Kyun? Pehla non-phony target listed; all phony hai isliye hamesha aage badhta hai.
calc ko main.o, math.o chahiye. Dono exist nahi karte → pattern rule do baar fire karta hai. Kyun? %.o:%.c har ek se stems main, math ke saath match karta hai.
Link step chalta hai. math.c edit karo, dobara chalao: sirf math.o aur calc rebuild hote hain — main.o main.c se newer hai, isliye skip. Kyun? §1 mein timestamp formula.

Worked example Example B — ek stem ke liye implicit rule override karna

# special-case: parser.c ko ek extra flag chahiye
parser.o: parser.c parser.h
	$(CC) $(CFLAGS) -DPARSER_DEBUG -c $< -o $@

Yahan parser.o ke liye explicit rule pattern/implicit wale ko haata deta hai (precedence §4.1). Note karo $< abhi bhi sirf parser.c hai (pehla prereq), jabki $^ hoga parser.c parser.h. parser.h kyun list karo? Taaki header edit karne par rebuild force ho — header compiler line mein pass nahi hota, sirf .c $< ke zariye hota hai.

Worked example Example C — phony bug live

Ek file banao: touch clean. make clean chalao bina .PHONY ke. Output:

make: 'clean' is up to date.

Kyun? §1 formula: target exist karta hai, koi prereq newer nahi → run nahi. .PHONY: clean add karo → recipe har baar chalti hai. Yahi textbook reason hai ki .PHONY kyun exist karta hai.

6. Forecast-then-Verify

Recall Aage padhne se pehle predict karo

Diya gaya:

%.o: %.c
	gcc -c $< -o $@
foo: foo.o bar.o
	gcc $^ -o $@

Q: touch bar.c ke baad, make foo par kaun si recipes chalti hain?

Answer: bar.o rebuild hota hai (uska .c newer hai), phir foo relink hota hai (ek prereq bar.o ab foo se newer hai). foo.o untouched rehta hai. Kya tumne foo ke relink ka forecast kiya? Woh cascade hi dependency graph ka poora point hai.

7. Flashcards

Make mein target "out of date" kab hota hai?

Jab woh missing ho, YA kam se kam ek prerequisite ka modification time target se newer ho.

clean ko .PHONY kyun chahiye?

Taaki disk par same-naam ki file ko already-built na samjha jaaye, jo recipe ko skip kar deti.

Pattern rule mein % kya capture karta hai?

Stem — woh substring jo, literal parts ke saath, target se match karta hai; wohi stem prerequisites mein reuse hota hai.

$@, $<, $^, $* ka matlab?

target, pehla prerequisite, saare prerequisites (deduped), stem.

Pattern rule aur implicit rule mein fark?

Pattern rule woh hota hai jo tum likhte ho; implicit rule ek built-in pattern rule hota hai jo Make ke saath pehle se aata hai (jaise %.o:%.c).

Make mein rule precedence order?

Explicit rule > tumhara pattern rule > built-in implicit rule.

Implicit rules mein compiler kaun sa variable select karta hai?

CC (default cc); make CC=clang se override karo.

Timestamps kyun, content hashing kyun nahi?

stat() timestamp check O(1) hai; hashing O(filesize) hai. Clock-correctness ki jagah speed.

%.o: %.c mein, net.o build karte waqt $* kya hai?

net (the stem).

Recall Feynman: 12-saal ke bache ko samjhao

LEGO instructions socho. Har step kehta hai "roof banane ke liye, pehle walls chahiye." Make ek robot hai jo yeh padhta hai. Yeh har piece par clock sticker dekhta hai: agar walls ko roof banne ke baad change kiya gaya, toh woh roof rebuild karta hai — warna time bachane ke liye skip karta hai. Phony steps woh kaam hain jaise "floor saaf karo" — "clean" naam ka koi LEGO piece nahi hai, isliye hum robot ko batate hain "yeh hamesha ek kaam hai, bas karo." Pattern rule ek instruction card hai jo har brick ke liye kaam karta hai: "koi bhi X-brick banane ke liye, uski X-stick lo aur snap karo." Implicit rule woh kaam hai jo robot pehle se dil se jaanta hai, isliye tum card bhi nahi likhte.

Connections

Makefile variables and expansion — := vs =, jahan CFLAGS rehta hai.
Dependency graphs and topological build order — §1 ke peeche ka DAG.
Incremental compilation — timestamps kyun sab-kuch-rebuild-na-karne enable karte hain.
CMake and Ninja — modern generators jo tumhare liye yeh rules emit karte hain.
Compiler flags CFLAGS LDFLAGS — implicit rules ke knobs.
Build reproducibility — kyun CC pin karna matter karta hai.