第30讲：Makefile基础

gcc hello.c -o hello

gcc a.c b.c c.c d.c e.c -o program

myproject/
├── main.c          # 主程序
├── math_utils.c    # 数学工具函数
├── math_utils.h    # 数学工具头文件
├── string_utils.c  # 字符串工具函数
├── string_utils.h  # 字符串工具头文件
├── logger.c        # 日志模块
└── logger.h        # 日志头文件

# 没有 Makefile 时，每次都要输入完整命令：
gcc -c main.c -o main.o
gcc -c math_utils.c -o math_utils.o
gcc -c string_utils.c -o string_utils.o
gcc -c logger.c -o logger.o
gcc main.o math_utils.o string_utils.o logger.o -o myprogram

# 如果只改了一行 math_utils.c，上面的命令仍然要全部执行一遍
# 项目有几十个文件时，这种方式根本不可行

# 第一次编译：
make
# 输出：编译所有 .c 文件，链接生成 myprogram

# 修改了 math_utils.c 后再次编译：
make
# 输出：只重新编译 math_utils.c，其他文件跳过

# 这就是"增量编译"的核心价值

修改源代码
    ↓
Make工具检查文件修改时间
    ↓
读取Makefile中的依赖关系
    ↓
找出需要重新编译的文件
    ↓
按Makefile中的规则逐个编译
    ↓
只编译受影响的部分，避免全量编译

# 创建测试文件
cat > hello.c << 'EOF'
#include <stdio.h>
int main() {
    printf("Hello\n");
    return 0;
}
EOF

# 编译生成可执行文件
gcc hello.c -o hello

# 查看文件时间戳
ls -l hello.c hello
# 输出示例：
# -rw-r--r-- 1 user user 102 Jul 24 10:00 hello.c
# -rwxr-xr-x 1 user user 16K Jul 24 10:01 hello    # 比 hello.c 新

# 此时如果执行 make，make 会检查：
#   hello 的修改时间（10:01）> hello.c 的修改时间（10:00）
#   结论：hello 是最新的，不需要重新编译 ✓

# 修改 hello.c
touch hello.c    # 模拟修改，更新了 hello.c 的时间戳

# 再次查看
ls -l hello.c hello
# 现在 hello.c 的时间戳（10:05）> hello 的时间戳（10:01）
# make 会判断：hello 过期了，需要重新编译！

# 规则格式：目标: 依赖
#          (Tab) 执行命令
hello: hello.c
	gcc hello.c -o hello

target: prerequisites
	recipe

# 这是注释，用 # 开头
# Makefile 文件名：Makefile 或 makefile 或 GNUmakefile

# 每条规则格式：目标: 依赖
#               (Tab)命令

# 最终目标：可执行文件 myprogram
myprogram: main.o math_utils.o string_utils.o logger.o
	gcc main.o math_utils.o string_utils.o logger.o -o myprogram

# 每个 .o 文件的编译规则
# 它们同时依赖对应的 .c 文件和 .h 头文件
main.o: main.c math_utils.h string_utils.h logger.h
	gcc -c main.c -o main.o

math_utils.o: math_utils.c math_utils.h
	gcc -c math_utils.c -o math_utils.o

string_utils.o: string_utils.c string_utils.h
	gcc -c string_utils.c -o string_utils.o

logger.o: logger.c logger.h
	gcc -c logger.c -o logger.o

# 执行 make 时，默认只构建第一个目标
# 假设有以下 Makefile：

all: program    # 第一个目标，make 默认执行这个

program: a.o b.o
	gcc a.o b.o -o program

a.o: a.c
	gcc -c a.c -o a.o

b.o: b.c
	gcc -c b.c -o b.o

clean:          # 这个目标不会自动执行
	rm -f program a.o b.o

# 构建项目（默认执行第一个目标 all）
make

# 清理编译产物（显式指定目标 clean）
make clean

# 只编译 a.o（指定中间目标）
make a.o

┌─────────────────────────────────────┐
│     项目（u-boot/内核/开源项目）       │
├─────────────────────────────────────┤
│          Makefile 管理               │
│   （编译 / 链接 / 库加载）             │
├─────────────────────────────────────┤
│       底层知识（编译/链接/库）         │
└─────────────────────────────────────┘

Makefile
├── ① 基本语法（核心）
│     └── 定义目标与依赖关系的格式
├── ② 变量
│     └── 记录特定信息，避免重复输入
├── ③ 条件判断
│     └── 控制编译器编译不同内容
├── ④ 头文件依赖
│     └── 管理头文件的依赖关系
├── ⑤ 隐含规则（模式规则）
│     └── 减少Makefile编写工作量
├── ⑥ 自动变量
│     └── 配合模式规则使用
└── ⑦ 函数
      └── Makefile内置的丰富功能

program: main.o utils.o
	gcc main.o utils.o -o program

main.o: main.c utils.h
	gcc -c main.c -o main.o

utils.o: utils.c utils.h
	gcc -c utils.c -o utils.o

clean:
	rm -f program main.o utils.o

# 用变量避免重复
CC       = gcc
CFLAGS   = -Wall -g
TARGET   = program
OBJS     = main.o utils.o

$(TARGET): $(OBJS)
	$(CC) $(OBJS) -o $(TARGET)

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

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

clean:
	rm -f $(TARGET) $(OBJS)

CC       = gcc
CFLAGS   = -Wall -g
TARGET   = program
OBJS     = main.o utils.o

$(TARGET): $(OBJS)
	$(CC) $^ -o $@        # $^ = 所有依赖, $@ = 目标名

# 模式规则：%.o 匹配所有 .o 文件，依赖同名的 .c 文件
%.o: %.c utils.h
	$(CC) $(CFLAGS) -c $< -o $@   # $< = 第一个依赖（.c 文件）

clean:
	rm -f $(TARGET) $(OBJS)

# 根据平台选择不同的编译选项
CC = gcc

ifeq ($(PLATFORM), arm)
    CC = arm-linux-gnueabihf-gcc
    CFLAGS = -march=armv7-a
else
    CFLAGS = -Wall -g
endif

TARGET = program
OBJS   = main.o utils.o

$(TARGET): $(OBJS)
	$(CC) $(CFLAGS) $^ -o $@

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

# 在 PC 上编译：
make

# 交叉编译给 ARM 板子：
make PLATFORM=arm

# 自动查找当前目录下所有 .c 文件
SRC_DIR  = .
SRCS     = $(wildcard $(SRC_DIR)/*.c)
OBJS     = $(patsubst %.c, %.o, $(SRCS))

TARGET = program

$(TARGET): $(OBJS)
	gcc $^ -o $@

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

clean:
	rm -f $(TARGET) $(OBJS)

# ============================================================
# 通用 Makefile 模板 - 适用于中小型 C 项目
# ============================================================

# 编译器设置
CC       = gcc
CFLAGS   = -Wall -Wextra -g -O2
LDFLAGS  =

# 目标和源文件
TARGET   = program
SRC_DIR  = src
OBJ_DIR  = build
SRCS     = $(wildcard $(SRC_DIR)/*.c)
OBJS     = $(patsubst $(SRC_DIR)/%.c, $(OBJ_DIR)/%.o, $(SRCS))

# 默认目标
all: $(TARGET)

# 链接
$(TARGET): $(OBJS)
	@echo "Linking $@ ..."
	$(CC) $(OBJS) $(LDFLAGS) -o $@
	@echo "Build complete: $@"

# 编译（自动创建 build 目录）
$(OBJ_DIR)/%.o: $(SRC_DIR)/%.c | $(OBJ_DIR)
	@echo "Compiling $< ..."
	$(CC) $(CFLAGS) -c $< -o $@

# 确保 build 目录存在
$(OBJ_DIR):
	mkdir -p $(OBJ_DIR)

# 清理
clean:
	@echo "Cleaning..."
	rm -rf $(OBJ_DIR) $(TARGET)

# 声明伪目标（避免和同名文件冲突）
.PHONY: all clean

# 使用这个模板
mkdir -p src build
echo `int main() { return 0; }` > src/main.c
make              # 编译
make clean        # 清理
make clean all    # 清理后重新编译

# 执行默认目标（Makefile 中的第一个目标）
make

# 执行指定目标
make clean
make all

# 指定 Makefile 文件名（默认按顺序查找：GNUmakefile, makefile, Makefile）
make -f mybuild.mk

# 在指定目录执行
make -C /path/to/project

# 查看 make 会执行哪些命令（不实际执行）——调试 Makefile 第一招
make -n
# 输出示例：
# gcc -c main.c -o main.o
# gcc -c utils.c -o utils.o
# gcc main.o utils.o -o program

# 打印 Makefile 中变量的值 —— 调试第二招
make -p | grep "CC "
# 或使用 info 函数在 Makefile 中打印：
#   $(info CC = $(CC))
#   $(info OBJS = $(OBJS))

# 查看隐式规则数据库
make -p | less

# 显示 make 的版本和内置变量
make --version

# 强制重建（忽略时间戳检查，适用于怀疑时间戳有问题时）
make -B

# 详细模式：打印每条规则的决策过程
make --debug=v

# 场景1：清理后重新编译
make clean && make

# 场景2：多核并行编译（4核）
make -j4

# 场景3：只编译不链接（生成 .o 文件）
make main.o utils.o

# 场景4：查看但不执行
make -n clean

# 场景5：交叉编译（传递变量给 make）
make CC=arm-linux-gnueabihf-gcc

# 模拟问题
echo "oops" > clean
make clean
# 输出：make: `clean` is up to date.
# clean 目标没有执行！因为有个叫 clean 的文件存在

.PHONY: clean all install

clean:
	rm -f *.o program

all: program

install:
	cp program /usr/local/bin/

# 即使有 clean 文件，也能正常执行
touch clean
make clean
# 输出：rm -f *.o program
# 正确执行了！

# 错误：recipe 前面用了空格而不是 Tab
program: main.c
    gcc main.c -o program    # 这行前面是 4 个空格，报错！

# 正确：recipe 前面必须是 Tab 字符
program: main.c
	gcc main.c -o program    # 这行前面是 1 个 Tab 字符

Makefile:2: *** missing separator.  Stop.

# 检查 Makefile 中是否有空格代替 Tab 的问题
cat -A Makefile | head -5
# 正确的输出应该类似：
# program: main.c$
# ^Igcc main.c -o program$    ← ^I 表示 Tab，正确

# Linux 文件名区分大小写！
# Makefile, makefile, GNUmakefile 是三个不同的文件

# make 查找 Makefile 的优先级（从高到低）：
# 1. GNUmakefile
# 2. makefile
# 3. Makefile

# 建议统一使用 Makefile（首字母大写），这是最通用的命名

# 错误：只依赖 .c 文件，没有包含头文件依赖
main.o: main.c
	gcc -c main.c -o main.o

# 如果修改了 utils.h，main.o 不会被重新编译！

# 正确：同时声明 .c 和 .h 依赖
main.o: main.c utils.h common.h
	gcc -c main.c -o main.o

# 默认情况下，make 会打印它执行的每条命令
program: main.o
	gcc main.o -o program
# 执行时输出:
# gcc main.o -o program     ← make 默认会回显命令

# 在命令前面加 @，可以禁止回显
program: main.o
	@echo "Building program..."
	@gcc main.o -o program
# 执行时输出:
# Building program...       ← 只输出 echo 的内容，命令本身不显示

# 创建项目目录
mkdir ~/makefile_demo
cd ~/makefile_demo

# 创建 main.c
cat > main.c << 'EOF'
#include <stdio.h>
#include "calc.h"

int main() {
    int a = 10, b = 5;
    printf("%d + %d = %d\n", a, b, add(a, b));
    printf("%d - %d = %d\n", a, b, sub(a, b));
    return 0;
}
EOF

# 创建 calc.c
cat > calc.c << 'EOF'
#include "calc.h"

int add(int a, int b) {
    return a + b;
}

int sub(int a, int b) {
    return a - b;
}
EOF

# 创建 calc.h
cat > calc.h << 'EOF'
#ifndef CALC_H
#define CALC_H

int add(int a, int b);
int sub(int a, int b);

#endif
EOF

# 创建 Makefile
cat > Makefile << 'EOF'
# 变量定义
CC      = gcc
CFLAGS  = -Wall -g
TARGET  = demo
OBJS    = main.o calc.o

# 默认目标：生成可执行文件
$(TARGET): $(OBJS)
	$(CC) $(OBJS) -o $(TARGET)
	@echo "Build success: ./$(TARGET)"

# 编译 main.o（依赖 main.c 和 calc.h）
main.o: main.c calc.h
	$(CC) $(CFLAGS) -c main.c -o main.o

# 编译 calc.o
calc.o: calc.c calc.h
	$(CC) $(CFLAGS) -c calc.c -o calc.o

# 清理
clean:
	rm -f $(TARGET) $(OBJS)
	@echo "Clean done"

# 声明伪目标
.PHONY: clean
EOF

# 第一步：查看项目文件
ls
# 输出：calc.c  calc.h  main.c  Makefile

# 第二步：编译
make
# 输出：
# gcc -Wall -g -c main.c -o main.o
# gcc -Wall -g -c calc.c -o calc.o
# gcc main.o calc.o -o demo
# Build success: ./demo

# 第三步：运行程序
./demo
# 输出：
# 10 + 5 = 15
# 10 - 5 = 5

# 第四步：验证增量编译
make
# 输出：make: `demo` is up to date.
# 没有任何文件被重新编译！

# 第五步：修改一个文件后重新编译
touch calc.c
make
# 输出：
# gcc -Wall -g -c calc.c -o calc.o
# gcc main.o calc.o -o demo
# Build success: ./demo
# 只重新编译了 calc.o，main.o 跳过了！

# 第六步：清理
make clean
# 输出：
# rm -f demo main.o calc.o
# Clean done

# 实验1：修改头文件后会发生什么？
touch calc.h
make
# 输出：main.o 和 calc.o 都会重新编译（因为两者都依赖 calc.h）
# 这就是"头文件依赖"的作用！

# 实验2：删除中间文件后会发生什么？
rm main.o
make
# 输出：只重新编译 main.o，calc.o 不重新编译
# 因为 calc.o 已经是最新的了

# 实验3：使用 -n 查看将要执行的操作
make -n clean
# 输出：rm -f demo main.o calc.o
# -n 选项让你看到 make 会执行什么，但不会真的执行