GNU Make

GNU Make는 소프트웨어 빌드 자동화를 위한 표준 도구입니다. Makefile 문법, 변수 할당 방식, 함수, 패턴/암묵적 규칙, 타겟 지정 변수, 순서 전용 의존성, 그룹 타겟, Makefile 지시자, 성능 최적화 등 GNU Make의 모든 기능을 GNU Make Manual 4.4를 기반으로 상세히 설명합니다.

개요 (Overview)

GNU Make는 1988년 Richard Stallman과 Roland McGrath가 개발한 빌드 자동화 도구로, Linux 커널을 포함한 대부분의 오픈소스 프로젝트에서 사용됩니다. Make는 파일 간의 의존성 관계를 선언하고, 변경된 파일만 다시 빌드하여 효율적인 컴파일 과정을 제공합니다.

왜 Make를 사용하는가?

• 선언적 빌드 — 타겟과 의존성을 선언하면, Make가 필요한 작업만 자동으로 수행합니다.
• 증분 빌드 — 타임스탬프 비교를 통해 변경된 파일만 재컴파일하여 빌드 시간을 단축합니다.
• 병렬 실행 — -j 옵션으로 독립적인 타겟을 병렬로 빌드할 수 있습니다.
• 이식성 — POSIX 호환 시스템에서 거의 동일하게 동작하며, 크로스 플랫폼 빌드를 지원합니다.
• 확장성 — 변수, 함수, 조건부 처리 등 강력한 기능으로 복잡한 빌드 로직을 구현할 수 있습니다.

기본 개념

Makefile은 다음 세 가지 핵심 요소로 구성됩니다.

1. 타겟(Target) — 빌드 결과물이나 작업 이름 (예: main.o, all, clean)
2. 의존성(Prerequisites) — 타겟을 빌드하기 전에 필요한 파일들 (예: main.c, header.h)
3. 레시피(Recipe) — 타겟을 생성하기 위한 셸 명령어 (반드시 탭 문자로 시작)

# 기본 Makefile 구조
target: prerequisite1 prerequisite2
	recipe-command1
	recipe-command2

기본 문법 (Basic Syntax)

간단한 Makefile 예제

# 변수 정의
CC = gcc
CFLAGS = -Wall -O2

# 기본 타겟
all: program

# 실행 파일 생성
program: main.o utils.o
	$(CC) -o $@ $^

# 오브젝트 파일 생성
main.o: main.c header.h
	$(CC) $(CFLAGS) -c main.c

utils.o: utils.c header.h
	$(CC) $(CFLAGS) -c utils.c

# PHONY 타겟
.PHONY: clean
clean:
	rm -f *.o program

자동 변수 (Automatic Variables)

Make는 레시피 실행 시 자동으로 설정되는 특수 변수를 제공합니다.

변수 (Variables)

변수 할당 방식

GNU Make는 4가지 변수 할당 연산자를 제공합니다.

# 재귀 확장 vs 즉시 확장
OPT = -O2
CFLAGS_LAZY = $(OPT) -Wall    # 사용 시점에 OPT 평가
CFLAGS_EAGER := $(OPT) -Wall  # 지금 바로 "-O2 -Wall"로 확장

OPT = -O3  # 나중에 변경

# 결과:
# CFLAGS_LAZY는 "-O3 -Wall"
# CFLAGS_EAGER는 "-O2 -Wall" (변경 영향 없음)

변수 할당 의사결정 플로차트

상황에 따라 적절한 변수 할당 연산자를 선택하는 것이 중요합니다. 아래 플로차트는 최적의 선택을 안내합니다.

변수 확장 동작 요약

Make가 Makefile을 읽을 때 두 단계로 처리합니다: 읽기 단계(Read Phase)와 실행 단계(Target-Update Phase). 각 할당 방식은 이 두 단계에서 다르게 동작합니다.

# :::= 예제: 즉시 확장 후 $ 이스케이프
var = first
OUT :::= $(var)     # 즉시 "first"로 확장됨
var = second          # OUT에 영향 없음
# $(OUT) → "first"

# != 예제: 쉘 명령어 결과 저장
UNAME != uname -s    # 쉘에서 실행: Linux, Darwin 등
DATE  != date +%Y-%m-%d
# 주의: != 로 저장된 변수는 재귀 확장 변수이므로
# 참조할 때마다 재평가됨 (쉘은 재실행 안 됨, 이미 저장된 값)

계산된 변수명 (Computed Variable Names)

변수명 자체를 다른 변수로 계산할 수 있습니다. 이를 중첩 변수 참조(Nested Variable Reference)라고 합니다.

# 기본 예: 변수명을 다른 변수로 지정
x = y
y = hello
result := $($(x))   # $(x) → y → $(y) → hello

# 실용적 활용: 아키텍처별 플래그 선택
CFLAGS_x86   = -march=x86-64
CFLAGS_arm   = -march=armv8-a
CFLAGS_riscv = -march=rv64gc

ARCH   ?= x86
CFLAGS += $(CFLAGS_$(ARCH))  # ARCH=arm이면 CFLAGS_arm 사용

# 다층 중첩 (3단계)
x = y
y = z
z = final_value
a := $($($(x)))              # → final_value

# 설정 기반 동적 변수 선택
a_dirs := dira dirb
1_dirs := dir1 dir2
a1 := a
df := dirs
result := $($(a1)_$(df))    # → "dira dirb"

치환 참조 (Substitution Reference)

변수 값의 일부를 패턴으로 치환할 수 있습니다.

# 확장자 치환
SRCS = main.c utils.c parser.c
OBJS = $(SRCS:.c=.o)  # main.o utils.o parser.o

# 패턴 치환
SRCS = src/main.c src/utils.c
OBJS = $(SRCS:src/%.c=build/%.o)  # build/main.o build/utils.o

# patsubst 함수 사용
OBJS = $(patsubst %.c,%.o,$(SRCS))

환경 변수

Make는 쉘 환경 변수를 자동으로 가져옵니다. Makefile 내 정의가 우선순위를 가지며, -e 옵션으로 환경 변수를 우선할 수 있습니다.

# 환경 변수 사용
CC ?= $(CROSS_COMPILE)gcc  # CROSS_COMPILE이 환경에서 설정되면 사용

타겟 지정 변수 (Target-specific Variables)

타겟 지정 변수는 특정 타겟과 그 의존성의 레시피 내에서만 유효한 변수를 정의합니다. 전역 변수와 동일한 이름을 사용하더라도 해당 타겟에서만 다른 값을 가집니다.

# 문법: TARGET : VARIABLE-ASSIGNMENT

# debug 타겟만 -g 플래그 사용
debug: CFLAGS = -g -O0 -DDEBUG
debug: program

release: CFLAGS = -O2 -DNDEBUG
release: program

# 의존성에도 전파됨!
prog: CFLAGS = -g
prog: prog.o foo.o bar.o
# → prog.o, foo.o, bar.o도 CFLAGS=-g로 컴파일됨

# 여러 키워드 조합 가능
install: override CFLAGS += -DINSTALL
test:    export VERBOSE = 1    # 자식 프로세스에도 export

# 상속 억제: private 키워드
EXTRA_CFLAGS =
prog: private EXTRA_CFLAGS = -L/usr/local/lib
prog: a.o b.o
# → a.o, b.o는 EXTRA_CFLAGS를 상속받지 않음

패턴 지정 변수 (Pattern-specific Variables)

패턴 지정 변수는 패턴과 일치하는 모든 타겟에 적용됩니다. 타겟 지정 변수와 유사하지만 와일드카드 패턴을 사용합니다.

# 문법: PATTERN : VARIABLE-ASSIGNMENT

# 모든 .o 파일을 최적화로 컴파일
%.o: CFLAGS := -O2

# lib/에 있는 .o는 위치 독립 코드
lib/%.o: CFLAGS := -fPIC -g

# 우선순위: 타겟 지정 > 패턴 지정 (더 긴 스템이 우선)
lib/%.o: CFLAGS := -fPIC -g     # 스템: lib/ 포함, 더 구체적
%.o: CFLAGS := -g               # 일반 .o 파일

# 예: 테스트 바이너리만 커버리지 활성화
test_%: CFLAGS += --coverage
test_%: LDFLAGS += --coverage

패턴 규칙 (Pattern Rules)

패턴 규칙은 % 와일드카드를 사용하여 여러 타겟에 동일한 빌드 규칙을 적용합니다.

암묵적 규칙 (Implicit Rules)

GNU Make는 일반적인 컴파일 작업을 위한 기본 패턴 규칙을 내장하고 있습니다.

# 내장 암묵적 규칙 (사용자가 정의하지 않아도 동작)
# %.o: %.c
#     $(CC) $(CFLAGS) $(CPPFLAGS) -c -o $@ $<

# 암묵적 규칙 덕분에 이렇게만 써도 동작
CC = gcc
CFLAGS = -Wall -O2

program: main.o utils.o
	$(CC) -o $@ $^

# main.o와 utils.o는 암묵적 규칙으로 자동 빌드됨

사용자 정의 패턴 규칙

# 모든 .c 파일을 .o로 컴파일하는 규칙
%.o: %.c
	$(CC) $(CFLAGS) -c -o $@ $<

# 여러 확장자를 처리하는 패턴
%.o: %.cpp
	$(CXX) $(CXXFLAGS) -c -o $@ $<

# 디렉토리 구조가 있는 경우
build/%.o: src/%.c
	@mkdir -p $(dir $@)
	$(CC) $(CFLAGS) -c -o $@ $<

정적 패턴 규칙 (Static Pattern Rules)

특정 타겟 목록에만 적용되는 패턴 규칙입니다.

OBJS = main.o utils.o parser.o

# OBJS에 속한 파일들에만 이 규칙 적용
$(OBJS): %.o: %.c
	$(CC) $(CFLAGS) -MMD -c -o $@ $<

# 다른 디렉토리 매핑
BUILD_OBJS = $(addprefix build/,$(OBJS))
$(BUILD_OBJS): build/%.o: src/%.c
	@mkdir -p $(dir $@)
	$(CC) $(CFLAGS) -c -o $@ $<

순서 전용 의존성 (Order-only Prerequisites)

파이프 기호 | 오른쪽에 지정된 의존성은 순서 전용입니다. 타겟의 빌드 순서를 보장하지만, 해당 의존성이 타겟보다 새로워도 타겟을 다시 빌드하지 않습니다.

# 문법: TARGETS : NORMAL-DEPS | ORDER-ONLY-DEPS

# 출력 디렉토리가 없으면 먼저 생성하되, 디렉토리 타임스탬프 변경으로
# .o 파일을 재빌드하지는 않음
OBJDIR := build
OBJS   := $(OBJDIR)/foo.o $(OBJDIR)/bar.o

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

all: $(OBJS)

$(OBJS): | $(OBJDIR)

$(OBJDIR):
	mkdir -p $@

# 일반 의존성: 해당 파일이 변경되면 타겟도 재빌드
# 순서 의존성: 해당 파일이 없으면 먼저 만들지만, 변경되어도 재빌드 안 함

그룹 타겟 (Grouped Targets)

단일 레시피 호출로 여러 파일이 동시에 생성될 때 &: 구분자를 사용하여 그룹 타겟으로 선언합니다. Make는 하나의 타겟이 필요하면 전체 레시피를 한 번만 실행합니다.

# 문법: TARGET1 TARGET2 &: PREREQUISITES

# protobuf 컴파일러는 .pb.h와 .pb.cc를 동시에 생성
foo.pb.h foo.pb.cc &: foo.proto
	protoc --cpp_out=. foo.proto

# 여러 출력 파일 동시 생성
foo bar biz &: baz boz
	generate_all $^

# $@ 는 트리거된 특정 타겟을 가리킴 (주의 필요)
# 그룹 더블 콜론: 동일 타겟을 여러 그룹에 포함 가능
foo bar &:: source1
	generate_foo_bar source1

foo baz &:: source2
	generate_foo_baz source2

더블 콜론 규칙 (Double-colon Rules)

더블 콜론 ::을 사용하면 동일한 타겟에 대해 독립적인 규칙 여러 개를 정의할 수 있습니다. 각 규칙은 자신의 의존성이 타겟보다 새로울 때 독립적으로 실행됩니다.

# 동일 타겟에 대한 두 가지 독립 업데이트 방법
config.h:: version.h
	@echo "Updating config from version.h"
	generate_config_from_version $<

config.h:: platform.h
	@echo "Updating config from platform.h"
	generate_config_from_platform $<

# 의존성 없는 더블 콜론: 항상 실행
clean::
	rm -f *.o

clean::
	rm -f *.d

# 단일 콜론 vs 더블 콜론:
# :: 규칙은 서로 독립적, 각 규칙 조건이 충족되면 별도로 실행
# :  규칙은 마지막 규칙의 레시피만 사용 (경고 발생)

함수 (Functions)

GNU Make는 문자열 조작, 파일 탐색, 조건 평가 등을 위한 다양한 내장 함수를 제공합니다.

텍스트 처리 함수

파일 이름 함수

제어 함수

함수 사용 예제

# foreach 루프
DIRS = src tests docs
all:
	$(foreach d,$(DIRS),$(MAKE) -C $(d);)

# call을 이용한 사용자 정의 함수
reverse = $(2) $(1)
foo := $(call reverse,a,b)  # foo = "b a"

# 복잡한 함수 예제: 소스에서 오브젝트 생성
src-to-obj = $(addprefix build/,$(patsubst %.c,%.o,$(notdir $(1))))
SRCS = src/main.c src/utils.c
OBJS = $(call src-to-obj,$(SRCS))  # build/main.o build/utils.o

# eval을 이용한 동적 규칙 생성
define COMPILE_TEMPLATE
$(1): $(2)
	$(CC) $(CFLAGS) -o $$@ $$<
endef

$(eval $(call COMPILE_TEMPLATE,main.o,main.c))
$(eval $(call COMPILE_TEMPLATE,utils.o,utils.c))

고급 함수 예제

# let 함수: 지역 변수 바인딩 (GNU Make 4.4+)
# 리스트의 첫 번째와 나머지를 분리
reverse = $(let first rest,$1,\
             $(if $(rest),$(call reverse,$(rest)) )$(first))

all:
	@echo $(call reverse,d c b a)   # → "a b c d"

# intcmp 함수: 정수 비교 (GNU Make 4.4+)
JOBS ?= 4
PARALLEL_MSG = $(intcmp $(JOBS),1,parallel,single,parallel)
# JOBS=1이면 "single", 아니면 "parallel"

MIN_VER := 4
MAKE_VER := $(firstword $(subst ., ,$(MAKE_VERSION)))
VER_OK  := $(intcmp $(MAKE_VER),$(MIN_VER),,ok,ok)
ifndef VER_OK
  $(error GNU Make 4.0 이상이 필요합니다. 현재: $(MAKE_VERSION))
endif

# value 함수: 확장 없이 원본 값 조회
FOO = $$PATH    # 재귀 확장 변수 (의도적으로 $ 포함)
all:
	@echo $(FOO)           # → (PATH 환경변수 값): ATH ($ 하나는 빈 변수)
	@echo $(value FOO)     # → "$PATH" (원본 문자열)

# file 함수: 파일 읽기/쓰기 (GNU Make 4.0+)
# 명령행이 너무 길 때 응답 파일(response file) 사용
program: $(OBJECTS)
	$(file >$@.rsp,$^)   # 목록을 파일에 쓰기 (덮어쓰기)
	$(LD) $(LDFLAGS) @$@.rsp -o $@
	@rm $@.rsp

# 각 오브젝트를 별도 줄로 쓰기
program: $(OBJECTS)
	$(file >$@.rsp) $(foreach O,$^,$(file >>$@.rsp,$O))
	$(LD) @$@.rsp -o $@

# 파일 내용 읽기
VERSION := $(file <version.txt)   # version.txt 내용을 변수에

# flavor 함수: 변수 종류 확인
$(info CC flavor: $(flavor CC))        # recursive
$(info SRCS flavor: $(flavor SRCS))    # simple (SRCS := ...으로 정의됨)
$(info UNDEFINED: $(flavor UNDEF_VAR)) # undefined

조건부 처리 (Conditional Directives)

Makefile 내에서 조건에 따라 다른 규칙이나 변수를 정의할 수 있습니다.

ifdef / ifndef

# 변수 정의 여부 확인
ifdef DEBUG
  CFLAGS += -g -DDEBUG
else
  CFLAGS += -O2 -DNDEBUG
endif

# 변수가 정의되지 않았을 때
ifndef CC
  CC = gcc
endif

ifeq / ifneq

# 값 비교
ifeq ($(CC),gcc)
  CFLAGS += -fdiagnostics-color=always
endif

# 불일치 비교
ifneq ($(ARCH),x86_64)
  CROSS_COMPILE ?= aarch64-linux-gnu-
endif

# 복잡한 조건
ifeq ($(shell uname -s),Linux)
  PLATFORM = linux
  LIBS += -lpthread
else ifeq ($(shell uname -s),Darwin)
  PLATFORM = macos
  LIBS += -framework CoreFoundation
else
  $(error Unsupported platform)
endif

Makefile 지시자 (Directives)

지시자(Directive)는 Makefile 파싱 중에 Make에게 특별한 처리를 지시하는 명령입니다.

include 지시자

include 지시자는 현재 Makefile 파싱을 일시 중단하고 다른 파일을 읽어들입니다.

# 기본 include
include config.mk rules.mk

# 와일드카드와 변수 사용 가능
include $(bar) *.mk

# 파일이 없어도 에러 없이 계속 (소프트 include)
-include $(DEPS)      # 의존성 파일이 없어도 무시
sinclude optional.mk   # -include의 다른 이름

# 여러 파일 한 번에 include
include a.mk b.mk $(c).mk

# include 검색 경로 추가 (명령행)
# $ make -I/path/to/includes
# 현재 include 검색 경로 확인
$(info Include dirs: $(.INCLUDE_DIRS))

define 지시자 (다중 라인 변수)

# 여러 줄 변수 정의
define NEWLINE


endef

# 기본값: 재귀 확장 (=)
define COMPILE_CMD
@echo "Compiling $(1) → $(2)"
$(CC) $(CFLAGS) -c -o $(2) $(1)
endef

# 즉시 확장 (:=)
define GREETING :=
Hello, $(USER)!
endef

# 조건부 할당 (?=)
define DEFAULT_FLAGS ?=
-Wall -Wextra
endef

# 추가 (+=)
define EXTRA_RECIPE +=
@echo "Additional step"
endef

undefine 지시자

# 변수 완전히 삭제 (마치 정의된 적 없는 것처럼)
TEMP_VAR = some_value
undefine TEMP_VAR
$(info flavor: $(flavor TEMP_VAR))  # → undefined

# ?= 와 undefine 비교:
# 변수를 빈 문자열로 정의: 여전히 "정의됨" → ?= 영향 없음
# undefine 후: "정의 안 됨" → ?= 가 효과를 발휘
EMPTY_VAR =
EMPTY_VAR ?= new_value   # 효과 없음 (이미 정의됨)
undefine EMPTY_VAR
EMPTY_VAR ?= new_value   # 이제 new_value가 됨

두 단계 파싱 (Two-phase Parsing)

GNU Make는 Makefile을 두 단계로 처리합니다. 이를 이해하면 변수와 함수의 확장 시점을 예측할 수 있습니다.

# 확장 시점 요약

# [즉시 확장] — 1단계에서 파싱 시 즉시
IMMEDIATE = DEFERRED         # 좌변: 즉시, 우변: 지연
IMMEDIATE := IMMEDIATE        # 좌변: 즉시, 우변: 즉시
IMMEDIATE ::= IMMEDIATE       # 좌변: 즉시, 우변: 즉시
IMMEDIATE :::= IMM-ESCAPED    # 즉시 확장 후 이스케이프
IMMEDIATE += DEF/IMM          # 이전 변수 종류에 따름
IMMEDIATE != IMMEDIATE        # 우변: 즉시 (쉘 실행)

# [타겟/의존성] — 1단계에서 즉시
# IMMEDIATE : IMMEDIATE ; DEFERRED
#             DEFERRED

# [조건 지시자] — 1단계에서 즉시 파싱 (자동 변수 사용 불가!)
ifdef DEBUG        # 1단계에서 평가됨 — $@, $< 등 사용 불가
  CFLAGS += -g
endif

# 잘못된 예: 레시피에서 조건문으로 자동 변수 사용 불가
# ifdef $@         ← 불가 (빈 문자열로 확장됨)

# 레시피에서는 쉘 조건문 사용해야 함
target:
	if [ "$(ARCH)" = "arm64" ]; then echo "ARM64"; fi

VPATH와 vpath

소스 파일이 여러 디렉토리에 분산되어 있을 때, Make가 파일을 찾을 수 있도록 검색 경로를 지정합니다.

VPATH 변수

# 모든 의존성 파일을 이 디렉토리들에서 검색
VPATH = src:include:../common

program: main.o utils.o
	$(CC) -o $@ $^

# Make가 src/, include/, ../common/에서 main.c와 utils.c를 자동으로 찾음

vpath 지시자

vpath는 특정 패턴의 파일에만 검색 경로를 지정합니다.

# .c 파일은 src/에서, .h 파일은 include/에서 찾기
vpath %.c src
vpath %.h include

# 여러 디렉토리 지정 (콜론으로 구분)
vpath %.c src:../common/src

# vpath 패턴 초기화
vpath %.c  # .c 파일의 검색 경로 제거
vpath       # 모든 vpath 설정 제거

고급 기법 (Advanced Techniques)

레시피 접두사 (Recipe Prefixes)

레시피 각 줄 앞에 특수 접두사를 붙여 Make의 동작을 제어할 수 있습니다. 접두사는 조합 가능합니다.

# @ : 명령어 출력 억제
all:
	@echo "=== 빌드 시작 ==="    # echo 명령어는 숨기고 결과만 출력
	@$(CC) -o program main.c    # 컴파일 명령어도 숨김

# - : 에러 무시
clean:
	-rm -f *.o program    # 파일이 없어도 에러 무시하고 계속
	-rmdir build/          # 디렉토리가 비어있지 않아도 무시

# + : 항상 실행 (-n 드라이런 중에도)
recursive:
	+$(MAKE) -C lib all   # 재귀 make는 항상 +를 사용 (jobserver 지원)

# 접두사 조합
install:
	@-mkdir -p $(DESTDIR)$(bindir)   # 조용하게, 에러 무시
	@install -m 755 $(PROGRAM) $(DESTDIR)$(bindir)

단일 쉘 실행 (.ONESHELL)

# 기본 동작: 각 레시피 줄마다 별도의 서브 쉘 실행
bad-example:
	VAR=hello
	echo $$VAR    # 빈 문자열 출력! 다른 쉘에서 실행됨

# .ONESHELL: 모든 레시피 줄을 하나의 쉘에서 실행
.ONESHELL:
good-example:
	VAR=hello
	echo $$VAR    # "hello" 출력

# .ONESHELL 활용: 복잡한 쉘 스크립트
.ONESHELL:
deploy:
	set -e         # 에러 시 즉시 종료
	echo "배포 시작..."
	ssh server "mkdir -p /opt/app"
	scp program server:/opt/app/
	ssh server "systemctl restart app"
	echo "배포 완료"

# 쉘 선택 (.SHELLFLAGS 포함)
SHELL = /bin/bash
.SHELLFLAGS = -eu -o pipefail -c   # 파이프 에러도 감지

자동 의존성 생성

GCC의 -MMD 옵션을 사용하여 헤더 파일 의존성을 자동으로 생성하고 포함시킵니다.

# 소스 파일 목록
SRCS = main.c utils.c parser.c
OBJS = $(SRCS:.c=.o)
DEPS = $(SRCS:.c=.d)

# 컴파일 시 .d 파일 자동 생성
%.o: %.c
	$(CC) $(CFLAGS) -MMD -MP -c -o $@ $<

# 의존성 파일 포함 (존재하지 않아도 에러 안 남)
-include $(DEPS)

clean:
	rm -f $(OBJS) $(DEPS) program

조용한 빌드 (Silent Build)

# @ 접두사: 명령어 출력 억제
all:
	@echo "Building project..."
	@$(MAKE) program

# .SILENT 특수 타겟: 전체 또는 특정 타겟 출력 억제
.SILENT: clean

clean:
	rm -f *.o program  # 명령어가 출력되지 않음

# 전역 조용한 모드
.SILENT:

병렬 빌드

Make는 -j 옵션으로 독립적인 타겟을 병렬로 빌드합니다.

# 최대 4개 작업 병렬 실행
$ make -j4

# CPU 코어 수만큼 병렬 실행
$ make -j$(nproc)

# Makefile 내에서 병렬 제어
.NOTPARALLEL: install  # install 타겟은 순차 실행

# 순서 의존성 명시
install: program
	@echo "Installing..."

# program이 완료된 후에만 install 실행됨

특수 내장 변수 (Special Variables)

GNU Make는 빌드 환경을 제어하는 특수 변수를 자동으로 제공합니다.

# 현재 Makefile의 디렉토리 경로 (include 된 Makefile에서 유용)
THIS_MAKEFILE := $(lastword $(MAKEFILE_LIST))
THIS_DIR      := $(dir $(abspath $(THIS_MAKEFILE)))

# 명령행 타겟에 따른 조건부 처리
ifeq ($(MAKECMDGOALS),clean)
  # clean 중에는 의존성 파일 읽지 않음
else
  -include $(DEPS)
endif

# 탭 대신 다른 문자로 레시피 구분
.RECIPEPREFIX = >
all:
> echo "탭 대신 > 사용"    # Makefile 보기 좋아짐

재귀 Make

대규모 프로젝트에서는 각 서브디렉토리마다 Makefile을 두고 재귀적으로 호출합니다.

# 최상위 Makefile
SUBDIRS = lib src tests

all:
	@for dir in $(SUBDIRS); do \
		$(MAKE) -C $$dir all || exit 1; \
	done

# 또는 foreach 사용
all:
	$(foreach dir,$(SUBDIRS),$(MAKE) -C $(dir) all &&) true

다중 라인 변수 (define)

# 여러 줄의 레시피를 변수로 정의
define COMPILE_RULE
@echo "Compiling $(1)..."
$(CC) $(CFLAGS) -c -o $(1) $(2)
@echo "Done."
endef

main.o: main.c
	$(call COMPILE_RULE,$@,$<)

이중 확장 (Secondary Expansion)

.SECONDEXPANSION을 사용하면 의존성을 두 번 확장하여 동적 의존성을 구현할 수 있습니다.

.SECONDEXPANSION:

SRCS_main = main.c utils.c
SRCS_test = test.c utils.c

# $$ 는 두 번째 확장 시 $ 로 평가됨
%: $$(SRCS_%)
	$(CC) -o $@ $^

# make main 실행 시 SRCS_main이 의존성으로 확장됨

크로스 컴파일 & 커널 빌드

Linux 커널과 임베디드 시스템 개발에서는 호스트 머신과 다른 아키텍처를 위한 크로스 컴파일이 필수입니다. GNU Make는 변수를 통해 크로스 컴파일을 쉽게 지원합니다.

커널 표준 변수

Linux 커널 빌드 시스템(Kbuild)은 다음 표준 변수를 사용합니다:

크로스 컴파일 예제

# ARM64 커널 빌드
$ make ARCH=arm64 CROSS_COMPILE=aarch64-linux-gnu- defconfig
$ make ARCH=arm64 CROSS_COMPILE=aarch64-linux-gnu- -j$(nproc)

# RISC-V 커널 빌드
$ make ARCH=riscv CROSS_COMPILE=riscv64-linux-gnu- defconfig
$ make ARCH=riscv CROSS_COMPILE=riscv64-linux-gnu- Image -j8

# Out-of-tree 빌드 (소스 트리를 깨끗하게 유지)
$ make O=../build-arm64 ARCH=arm64 defconfig
$ make O=../build-arm64 ARCH=arm64 -j$(nproc)

# 외부 커널 모듈 빌드
$ make -C /lib/modules/$(uname -r)/build M=$(pwd) modules
$ make -C /lib/modules/$(uname -r)/build M=$(pwd) modules_install

# Clang으로 커널 빌드 (LLVM 툴체인)
$ make CC=clang LD=ld.lld AR=llvm-ar NM=llvm-nm OBJCOPY=llvm-objcopy -j$(nproc)

# 또는 LLVM=1 단축 옵션 (커널 5.7+)
$ make LLVM=1 -j$(nproc)

외부 커널 모듈 Makefile 예제

# 외부 모듈용 Makefile (/home/user/mydriver/Makefile)
obj-m := mydriver.o
mydriver-objs := main.o ioctl.o interrupt.o

# 다중 파일 소스
ccflags-y := -DDEBUG -I$(src)/include

# 커널 소스 트리 경로
KDIR ?= /lib/modules/$(shell uname -r)/build
PWD := $(shell pwd)

all:
	$(MAKE) -C $(KDIR) M=$(PWD) modules

clean:
	$(MAKE) -C $(KDIR) M=$(PWD) clean

install:
	$(MAKE) -C $(KDIR) M=$(PWD) modules_install

.PHONY: all clean install

일반 프로젝트 크로스 컴파일

# 범용 크로스 컴파일 Makefile
CROSS_COMPILE ?=
CC := $(CROSS_COMPILE)gcc
AR := $(CROSS_COMPILE)ar
LD := $(CROSS_COMPILE)ld
STRIP := $(CROSS_COMPILE)strip

# 타겟별 플래그
ifeq ($(ARCH),arm)
  CFLAGS += -march=armv7-a -mfpu=neon
else ifeq ($(ARCH),arm64)
  CFLAGS += -march=armv8-a
else ifeq ($(ARCH),riscv)
  CFLAGS += -march=rv64gc -mabi=lp64d
endif

program: $(OBJS)
	$(CC) $(LDFLAGS) -o $@ $^ $(LIBS)
	$(STRIP) $@

# 사용 예:
# make ARCH=arm64 CROSS_COMPILE=aarch64-linux-gnu-

성능 최적화

대규모 프로젝트에서는 빌드 시간이 개발 생산성에 직접적인 영향을 미칩니다. 다음 기법으로 Make 빌드를 최적화할 수 있습니다.

ccache — 컴파일 캐시

ccache는 컴파일 결과를 캐시하여 이전에 빌드한 적이 있는 파일은 재컴파일하지 않습니다. 커널 개발처럼 자주 make clean하는 경우 매우 효과적입니다.

# ccache 설치
$ sudo apt install ccache    # Debian/Ubuntu
$ sudo dnf install ccache    # Fedora/RHEL

# Makefile에 통합
CC := ccache gcc
CXX := ccache g++

# 또는 환경 변수로 전역 활성화
$ export CC="ccache gcc"
$ export CXX="ccache g++"

# 커널 빌드 시
$ make CC="ccache gcc" -j$(nproc)

# 캐시 통계 확인
$ ccache -s

distcc — 분산 컴파일

distcc는 컴파일 작업을 네트워크상의 여러 머신에 분산시킵니다. 팀 개발 환경에서 유휴 머신을 빌드 서버로 활용할 수 있습니다.

# distcc 서버 설정 (빌드 서버)
$ sudo apt install distcc
$ distccd --daemon --allow 192.168.1.0/24

# 클라이언트 설정 (개발 머신)
$ export DISTCC_HOSTS="localhost 192.168.1.10 192.168.1.11"
$ export CC="distcc gcc"

# 병렬도를 머신 수 * 코어 수로 설정
$ make -j20 CC="distcc gcc"

# distcc 통계 확인
$ distccmon-text 1

병렬 빌드 최적화

-j 옵션의 최적 값은 CPU 코어 수와 작업 특성에 따라 다릅니다.

# CPU 코어 수만큼 (일반적인 선택)
$ make -j$(nproc)

# I/O 바운드 작업은 코어 수의 1.5-2배
$ make -j$(($(nproc) * 2))

# ccache와 함께 사용 시 더 높은 병렬도 허용
$ make -j$(($(nproc) * 3)) CC="ccache gcc"

# 메모리가 부족하면 병렬도 낮추기
$ make -j4  # 링크 단계에서 OOM 방지

# Makefile에서 기본 병렬도 설정 (GNU Make 4.3+)
MAKEFLAGS += -j$(shell nproc)

의존성 최적화

불필요한 의존성은 병렬성을 저해하고 빌드 시간을 늘립니다.

# 잘못된 예: 모든 파일이 common.h에 의존
OBJS = main.o utils.o parser.o network.o
$(OBJS): common.h  # common.h 수정 시 모두 재컴파일

# 올바른 예: 실제 의존성만 선언
main.o: main.c common.h
utils.o: utils.c common.h
parser.o: parser.c        # common.h 불필요
network.o: network.c      # common.h 불필요

# 더 나은 방법: -MMD로 자동 의존성 생성
%.o: %.c
	$(CC) $(CFLAGS) -MMD -MP -c $<

-include $(DEPS)

증분 빌드 전략

# 링크 시간 최적화(LTO) 비활성화 (개발 중)
ifdef DEBUG
  CFLAGS += -g -O0
else
  CFLAGS += -O2 -flto  # 릴리스만 LTO
endif

# 미리 컴파일된 헤더 (PCH) 사용 (대규모 C++ 프로젝트)
pch.h.gch: pch.h
	$(CXX) $(CXXFLAGS) -x c++-header $< -o $@

%.o: %.cpp pch.h.gch
	$(CXX) $(CXXFLAGS) -include pch.h -c $<

# Unity build (모든 소스를 하나의 컴파일 단위로)
# 빌드는 빠르지만 증분 빌드 불가, 릴리스 전용
all_sources.o: $(SRCS)
	echo '$(SRCS)' | tr ' ' '\n' | sed 's/^/#include "/' | sed 's/$$/"/' > all.cpp
	$(CXX) $(CXXFLAGS) -c all.cpp -o $@

빌드 시간 프로파일링

# Make가 수행한 작업 시간 측정
$ make --debug=v 2>&1 | grep "Considering"

# 각 명령어 실행 시간 측정
$ time make -j$(nproc)

# 병렬 빌드 시각화 (GNU Make 4.0+)
$ make -j8 --output-sync=target

# 커널 빌드 시간 상세 분석
$ scripts/build-time.sh  # 커널 소스 트리 내

# Makefile에 타이머 추가
BUILD_START := $(shell date +%s)
all: $(TARGET)
	@echo "Build completed in $$(($$(date +%s) - $(BUILD_START))) seconds"

특수 타겟 (Special Targets)

GNU Make는 빌드 동작을 제어하는 특수한 내장 타겟을 제공합니다.

# PHONY 타겟 선언 (실제 파일 이름과 충돌 방지)
.PHONY: all clean install test

# 에러 발생 시 생성된 파일 자동 삭제
.DELETE_ON_ERROR:

# 모든 레시피를 하나의 쉘에서 실행 (변수 공유 가능)
.ONESHELL:
test:
	VAR=hello
	echo $$VAR  # .ONESHELL 없으면 빈 문자열 출력

암묵적 규칙 목록 (Built-in Implicit Rules)

GNU Make는 일반적인 파일 변환을 위한 내장 암묵적 규칙을 제공합니다. 확장자로 자동 선택되며, 관련 변수를 재정의하면 동작을 변경할 수 있습니다.

내장 암묵적 규칙 목록

암묵적 규칙에서 사용하는 표준 변수

# 암묵적 규칙 활용 예: 최소한의 Makefile
CC     = gcc
CFLAGS = -Wall -O2
LDLIBS = -lm

# 명시적 규칙 없이도 program: main.o utils.o 후
# Make가 자동으로 %.o: %.c 암묵적 규칙 적용
program: main.o utils.o

# 암묵적 규칙 비활성화: 명시적 빈 규칙으로
%.o: %.s    # 어셈블러 암묵적 규칙 비활성화

# 또는 전역 비활성화 (성능 향상)
# $ make -r   (--no-builtin-rules)

# 라이브러리 링크: -lNAME 형식
# Make가 libNAME.so, libNAME.a 를 자동 탐색
foo: foo.c -lcurses
	$(CC) $^ -o $@
# → cc foo.c /usr/lib/libcurses.a -o foo

# 암묵적 규칙 체인 (chaining)
# foo.o → foo.c 없지만 foo.y 있으면: foo.y → foo.c → foo.o 자동 체인

암묵적 규칙 탐색 순서

Make는 타겟에 맞는 암묵적 규칙을 다음 순서로 탐색합니다:

1. Makefile에 정의된 패턴 규칙 (사용자 정의)
2. 내장 암묵적 규칙 (Built-in)
3. 접미사 규칙 (Suffix rules, 구식)
4. 마지막 수단 기본 규칙 (.DEFAULT)

# 암묵적 규칙 탐색 디버깅
$ make --debug=i target   # -i: implicit rules 탐색 과정 출력

# 모든 규칙과 변수 출력
$ make -p | less

# 내장 규칙 없이 (더 빠른 빌드, 규칙을 모두 명시)
$ make -r -R   # --no-builtin-rules --no-builtin-variables

디버깅 (Debugging)

유용한 Make 옵션

--debug 상세 레벨

디버깅 기법

# 변수 값 확인
$(info SRCS = $(SRCS))
$(info OBJS = $(OBJS))

# 변수 출처 확인
$(info CC origin: $(origin CC))

# 조건부 디버깅
ifdef DEBUG_MAKEFILE
  $(info Building target $@)
  $(info Dependencies: $^)
endif

# 함수 결과 확인
$(info wildcard *.c = $(wildcard *.c))

# 특정 타겟만 trace
$ make --trace main.o

자주 발생하는 문제

빌드 오류 진단 가이드

Make 빌드 오류는 다양한 원인으로 발생합니다. 아래 가이드는 빠른 문제 해결을 돕습니다.

Makefile 작성 관례 (Makefile Conventions)

GNU Coding Standards와 POSIX 표준은 이식성과 일관성을 위한 Makefile 작성 관례를 정의합니다. 이러한 관례를 따르면 사용자가 직관적으로 프로젝트를 빌드하고 설치할 수 있습니다.

표준 타겟 (Standard Targets)

대부분의 프로젝트는 다음 표준 타겟을 제공해야 합니다:

# 표준 타겟 예제
.PHONY: all install uninstall clean distclean check

all: $(PROGRAMS) $(LIBRARIES)

install: all
	install -d $(DESTDIR)$(bindir)
	install -m 755 $(PROGRAMS) $(DESTDIR)$(bindir)

clean:
	rm -f *.o $(PROGRAMS)

distclean: clean
	rm -f Makefile config.h

check: all
	./run-tests.sh

표준 변수 (Standard Variables)

GNU Coding Standards는 일관된 변수명을 권장합니다. 대문자로 작성하며, 사용자가 명령행에서 재정의할 수 있어야 합니다.

컴파일러 및 도구

컴파일 플래그

# 표준 변수 사용 예제
CC       ?= gcc
CFLAGS   ?= -Wall -O2
CPPFLAGS ?= -Iinclude
LDFLAGS  ?=
LDLIBS   ?= -lm

# 올바른 링크 명령 순서
program: main.o utils.o
	$(CC) $(LDFLAGS) -o $@ $^ $(LDLIBS)

# 올바른 컴파일 명령
%.o: %.c
	$(CC) $(CPPFLAGS) $(CFLAGS) -c -o $@ $<

디렉토리 변수 (Directory Variables)

설치 경로를 제어하는 표준 변수들입니다. GNU Autotools (autoconf/automake)와 호환되도록 작성하세요.

# 디렉토리 변수 정의 예제
prefix      ?= /usr/local
exec_prefix ?= $(prefix)
bindir      ?= $(exec_prefix)/bin
libdir      ?= $(exec_prefix)/lib
includedir  ?= $(prefix)/include
datarootdir ?= $(prefix)/share
mandir      ?= $(datarootdir)/man

# DESTDIR 지원 (staged install)
install: all
	install -d $(DESTDIR)$(bindir)
	install -m 755 $(PROGRAM) $(DESTDIR)$(bindir)
	install -d $(DESTDIR)$(mandir)/man1
	install -m 644 doc/$(PROGRAM).1 $(DESTDIR)$(mandir)/man1

# 사용 예: make install DESTDIR=/tmp/staging prefix=/usr

파일명 관례

• Makefile: 표준 파일명. 거의 모든 프로젝트에서 사용합니다.
• GNUmakefile: GNU Make 전용 기능을 사용하는 경우. Makefile보다 우선 순위가 높습니다.
• makefile: 소문자 형태. POSIX 표준이지만 권장하지 않습니다 (가독성 저하).
• *.mk: include용 조각 파일 (예: rules.mk, config.mk)

코딩 관례

들여쓰기

• 레시피 (Recipe): 반드시 탭 문자 (Tab)로 시작해야 합니다. 공백 8개는 작동하지 않습니다!
• 변수 정의, 규칙 헤더: 들여쓰기 없이 줄 시작 부분에 작성합니다.
• 조건문 본문: 공백 2칸 또는 탭으로 들여쓰기 (가독성 향상, 문법적으로 불필요).

변수명

• 대문자 사용: Make 변수는 전통적으로 대문자로 작성합니다 (CFLAGS, SOURCES).
• 밑줄 구분: 단어 구분에는 밑줄을 사용합니다 (BUILD_DIR, SRC_FILES).
• 내부 변수: 프로젝트 내부용 변수는 소문자나 접두사로 구분할 수 있습니다 (_internal_var).

PHONY 타겟

• 파일을 생성하지 않는 타겟은 항상 .PHONY로 선언하세요.
• 예: all, clean, install, test, help

.PHONY: all clean install test help

all: $(TARGET)

clean:
	rm -f *.o $(TARGET)

기타 권장 사항

• ?= 사용: 사용자가 환경 변수나 명령행에서 재정의할 수 있도록 ?=를 사용하세요.

  CC ?= gcc
  CFLAGS ?= -Wall -O2
  

• .DEFAULT_GOAL 설정: 명시적으로 기본 타겟을 지정하려면:

  .DEFAULT_GOAL := all
  

• .DELETE_ON_ERROR 사용: 레시피 실행 중 에러 발생 시 타겟 파일을 자동 삭제합니다.

  .DELETE_ON_ERROR:
  

• .SUFFIXES 초기화: 불필요한 암묵적 규칙 비활성화:

  .SUFFIXES:
  .SUFFIXES: .c .o
  

크로스 컴파일 지원

ARM, MIPS 등 다른 아키텍처를 대상으로 빌드할 때 사용하는 관례입니다.

# 크로스 컴파일러 접두사
CROSS_COMPILE ?=

CC  := $(CROSS_COMPILE)gcc
AR  := $(CROSS_COMPILE)ar
LD  := $(CROSS_COMPILE)ld

# 사용 예
# make CROSS_COMPILE=arm-linux-gnueabihf-
# → CC=arm-linux-gnueabihf-gcc

Linux 커널도 동일한 방식을 사용합니다:

$ make ARCH=arm64 CROSS_COMPILE=aarch64-linux-gnu-

Help 타겟 추가

사용자 편의를 위해 make help 타겟을 제공하는 것이 좋습니다.

.PHONY: help
help:
	@echo "사용 가능한 타겟:"
	@echo "  all          - 전체 빌드 (기본)"
	@echo "  clean        - 빌드 결과물 삭제"
	@echo "  install      - 시스템에 설치"
	@echo "  test         - 테스트 실행"
	@echo ""
	@echo "변수:"
	@echo "  CC           - C 컴파일러 (기본: gcc)"
	@echo "  CFLAGS       - 컴파일 옵션 (기본: -Wall -O2)"
	@echo "  prefix       - 설치 경로 (기본: /usr/local)"
	@echo ""
	@echo "예: make install prefix=/opt/myapp"

또는 자동으로 주석에서 추출하는 방법:

.PHONY: help
help: ## 도움말 출력
	@grep -E '^[a-zA-Z_-]+:.*?## .*$$' $(MAKEFILE_LIST) | \
		awk 'BEGIN {FS = ":.*?## "}; {printf "  \033[36m%-15s\033[0m %s\n", $$1, $$2}'

all: ## 전체 빌드
	...

clean: ## 빌드 결과물 삭제
	...

실전 패턴 및 모범 사례

프로젝트 구조 예제

# 디렉토리 구조
# project/
#   ├── Makefile
#   ├── src/
#   ├── include/
#   ├── build/
#   └── lib/

# === 변수 정의 ===
CC       := gcc
CFLAGS   := -Wall -Wextra -std=c11
CPPFLAGS := -Iinclude
LDFLAGS  := -Llib
LDLIBS   := -lm

# 빌드 설정
BUILD_DIR := build
SRC_DIR   := src
INC_DIR   := include

# === 소스 파일 수집 ===
SRCS := $(wildcard $(SRC_DIR)/*.c)
OBJS := $(patsubst $(SRC_DIR)/%.c,$(BUILD_DIR)/%.o,$(SRCS))
DEPS := $(patsubst $(SRC_DIR)/%.c,$(BUILD_DIR)/%.d,$(SRCS))

TARGET := $(BUILD_DIR)/program

# === 디버그/릴리스 모드 ===
ifdef DEBUG
  CFLAGS += -g -O0 -DDEBUG
else
  CFLAGS += -O2 -DNDEBUG
endif

# === 기본 타겟 ===
.PHONY: all clean install test

all: $(TARGET)

# === 링크 ===
$(TARGET): $(OBJS)
	@mkdir -p $(dir $@)
	$(CC) $(LDFLAGS) -o $@ $^ $(LDLIBS)
	@echo "Build complete: $@"

# === 컴파일 ===
$(BUILD_DIR)/%.o: $(SRC_DIR)/%.c
	@mkdir -p $(dir $@)
	$(CC) $(CPPFLAGS) $(CFLAGS) -MMD -MP -c -o $@ $<

# === 의존성 포함 ===
-include $(DEPS)

# === 정리 ===
clean:
	rm -rf $(BUILD_DIR)

# === 설치 ===
PREFIX ?= /usr/local
install: $(TARGET)
	install -D -m 755 $(TARGET) $(PREFIX)/bin/$(notdir $(TARGET))

# === 디버그 정보 출력 ===
print-%:
	@echo '$*=$($*)'

# 사용: make print-SRCS

모범 사례 및 팁

• 즉시 확장(:=) 우선: 성능과 예측 가능성을 위해 :=를 기본으로 사용하세요.
• 자동 의존성 생성: -MMD -MP로 헤더 의존성을 자동 관리하세요.
• 빌드 디렉토리 분리: 소스와 빌드 결과물을 분리하여 make clean을 간단하게 만드세요.
• PHONY 타겟 선언: all, clean 등은 항상 .PHONY로 선언하세요.
• @ 접두사 활용: 핵심 명령어만 출력하고 부가 명령어는 @로 숨기세요.
• 에러 처리: .DELETE_ON_ERROR를 사용하여 실패한 타겟을 자동 삭제하세요.
• 변수명 규칙: CC, CFLAGS, LDFLAGS 등 표준 변수명을 따르세요.
• PREFIX 지원: PREFIX ?= /usr/local로 사용자 정의 설치 경로를 지원하세요.
• 병렬 빌드 친화적: 타겟 간 의존성을 명확히 선언하여 -j 옵션이 안전하게 동작하도록 하세요.

빠른 참조 (Quick Reference)

자동 변수 전체 목록

함수 빠른 참조

자주 쓰는 make 옵션

실무 Makefile 운영 플레이북

문법 이해만으로는 대규모 빌드를 안정적으로 운영하기 어렵습니다. 실제 프로젝트에서는 재현성, 증분 정확성, 디버깅 가능성을 동시에 관리해야 합니다.

안정성 규칙

• PHONY 명시: 파일이 아닌 타겟은 반드시 .PHONY에 등록합니다.
• 자동 의존성: -MMD -MP로 헤더 의존성을 자동 생성합니다.
• 순서 전용 의존성: 디렉토리 생성은 | 의존성으로 분리합니다.
• 변수 정책 고정: 재귀 확장(=)과 단순 확장(:=)을 혼용할 때 의도를 주석으로 남깁니다.
• 병렬 안전: 레시피에서 공유 파일 쓰기 경합이 없도록 설계합니다.

재현성 점검 루틴

# 1) 깨끗한 상태에서 빌드
make clean
make -j$(nproc)

# 2) 무변경 재빌드 (아무것도 다시 빌드되면 의존성 선언 의심)
make -j$(nproc)

# 3) 드라이런으로 실행 명령 확인
make -n

# 4) 어떤 이유로 재빌드되는지 추적
make --debug=b target 2>&1 | less

관련 문서

• 빌드 시스템 (Kbuild) — Linux 커널의 Kbuild 시스템 (GNU Make 기반)
• 커널 개발 도구 — GCC, Clang, 정적 분석 도구
• 커널 모듈 — 모듈 빌드 과정
• 참고자료 — GNU Make 공식 매뉴얼 링크

참고 자료 (References)

• GNU Make Manual — 공식 매뉴얼 (4.4)
• POSIX make Specification — POSIX.1-2017 표준
• Peter Miller, "Recursive Make Considered Harmful" — 재귀 Make의 문제점과 비재귀 대안
• Makefile Tutorial — 실습 중심 튜토리얼
• man make — 시스템 매뉴얼 페이지
• make --version — 현재 설치된 GNU Make 버전 확인
• info make — GNU Info 형식의 상세 문서