Compilação separada e Make

Na página de Tipo Abstrato de Dados, um programa passou a ter vários arquivos .c e .h. Esta página trata das ferramentas para compilar esses programas: as etapas da compilação, a compilação de cada arquivo em separado e o make, que automatiza todo o processo. As flags usadas em cada comando são as mesmas de sempre, explicadas em Compilando em C.

Do código ao executável

O comando gcc faz, na verdade, três trabalhos diferentes:

1. Pré-processamento: trata as linhas que começam com #. Cada #include é trocado pelo conteúdo do arquivo incluído, cada #define é substituído onde aparece, e os trechos desligados por #if/#ifdef são removidos. Para ver o resultado, use gcc -E arquivo.c.
2. Compilação: traduz cada arquivo .c, já pré-processado, para código de máquina, gerando um arquivo objeto (.o). Cada .c é compilado sozinho: o compilador não olha os outros arquivos do projeto, só os protótipos que vieram dos #include.
3. Ligação: o ligador (ld) junta os arquivos objeto e o código das bibliotecas usadas em um único executável. É aqui que cada chamada é associada ao código da função chamada.

Saber em que etapa um erro aconteceu ajuda a entender a mensagem:

Os erros de ligação aparecem com ld ou collect2 na mensagem e citam o arquivo objeto, não uma linha do código: o programa compilou, mas falta (ou sobra) alguma função na hora de juntar as partes.

Compilando em etapas

-c interrompe o processo depois da compilação: gcc -c Aluno.c gera Aluno.o, e a ligação fica para um comando posterior. Assim, cada .c pode ser compilado separadamente, e só o que mudou precisa ser compilado de novo.

gcc -c Aluno.c                       # Aluno.o
gcc -c main.c                        # main.o
gcc main.o Aluno.o -o TADAluno       # executável TADAluno

Na prática, cada comando leva as flags da disciplina. Duas delas exigem atenção quando a compilação é feita em etapas.

Make

Em um projeto com muitos arquivos, é fácil esquecer o que precisa ser recompilado depois de uma alteração. Recompilar tudo sempre funciona, mas é lento, e recompilar "de cabeça" é arriscado: um .o desatualizado gera um executável que não corresponde ao código. O make resolve isso: ele lê as regras de um arquivo chamado Makefile, compara as datas de modificação dos arquivos e refaz só o que ficou desatualizado.

Regras

Um Makefile é uma lista de regras no formato:

alvo: pré-requisitos
	comando
	comando

• alvo (target): o arquivo a ser gerado, como main.o ou o executável;
• pré-requisitos: os arquivos de que o alvo depende. Se algum deles for mais novo que o alvo, o alvo está desatualizado;
• comandos: o que fazer para gerar o alvo.

Um primeiro Makefile

Para o TAD Aluno (arquivos main.c, Aluno.c e Aluno.h):

all: TADAluno

TADAluno: main.o Aluno.o
	gcc main.o Aluno.o -o TADAluno

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

Aluno.o: Aluno.c Aluno.h
	gcc -c Aluno.c

clean:
	rm -f *.o TADAluno

run: TADAluno
	./TADAluno

Digitando make, o primeiro alvo do arquivo (all) é construído. Ele depende de TADAluno, que depende de main.o e Aluno.o, que dependem dos fontes. O make percorre essas dependências e executa os comandos na ordem necessária:

$ make
gcc -c main.c
gcc -c Aluno.c
gcc main.o Aluno.o -o TADAluno

Rodando de novo, sem alterar nada:

$ make
make: Nothing to be done for 'all'.

Agora altere só Aluno.c (um comentário basta) e rode make:

$ make
gcc -c Aluno.c
gcc main.o Aluno.o -o TADAluno

Aluno.o ficou mais velho que Aluno.c e foi recompilado. main.o continua mais novo que main.c e Aluno.h, e não precisou ser tocado. Mas o novo Aluno.o é mais novo que TADAluno, e o executável foi ligado de novo.

Alvos que não são arquivos

all, clean e run não geram arquivos com esses nomes: são apenas nomes para ações. Os nomes mais comuns são all (o primeiro alvo, construído por um make sem argumentos), clean (apaga o que foi gerado) e run (executa o programa).

make          # constrói o primeiro alvo (all)
make run      # constrói, se necessário, e executa
make clean    # apaga os .o e o executável

Há um detalhe: se existir um arquivo chamado clean na pasta, o make acha que o alvo já está pronto e não faz nada:

$ make clean
make: 'clean' is up to date.

Para evitar isso, declare esses alvos como .PHONY (falsos): o make passa a executá-los sempre, sem procurar um arquivo com o nome.

.PHONY: all clean run

Variáveis

O Makefile acima ainda não usa as flags da disciplina. Copiá-las em cada comando seria repetitivo e fácil de errar. Em vez disso, use variáveis:

CFLAGS = -std=c11 -O0 -g -Wall -Wextra -Werror

e escreva $(CFLAGS) onde elas forem usadas. Para trocar uma flag, basta alterar uma linha. Alguns nomes são convenções seguidas pela maioria dos projetos:

Variáveis automáticas e o @

Dentro de uma regra, o make define algumas variáveis automaticamente:

Na regra main.o: main.c Aluno.h, $@ é main.o, $< é main.c e $^ é main.c Aluno.h. Assim, o comando de compilação fica $(CC) $(CFLAGS) -c $<, sem repetir o nome do arquivo.

Por padrão, o make mostra cada comando antes de executá-lo. Um @ no começo do comando esconde essa linha, o que é útil para trocar comandos longos por mensagens curtas com echo.

Um Makefile completo

Juntando tudo:

# Makefile do TAD Aluno

CC      = gcc
CFLAGS  = -std=c11 -O0 -g -fno-omit-frame-pointer \
          -Wall -Wextra -Werror -Wshadow \
          -Wno-sign-compare -Wno-unused-parameter \
          -Wno-unused-variable -Wno-unused-result \
          -fsanitize=address,undefined
LDFLAGS = -fsanitize=address,undefined
LDLIBS  = -lm
EXECUTAVEL = TADAluno

all: $(EXECUTAVEL)

$(EXECUTAVEL): main.o Aluno.o
	@echo "Ligando $^ em $@"
	@$(CC) $^ $(LDFLAGS) $(LDLIBS) -o $@

main.o: main.c Aluno.h
	@echo "Compilando $<"
	@$(CC) $(CFLAGS) -c $<

Aluno.o: Aluno.c Aluno.h
	@echo "Compilando $<"
	@$(CC) $(CFLAGS) -c $<

run: $(EXECUTAVEL)
	./$(EXECUTAVEL)

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

.PHONY: all run clean

$ make
Compilando main.c
Compilando Aluno.c
Ligando main.o Aluno.o em TADAluno

Repare que -fsanitize=address,undefined aparece em CFLAGS e em LDFLAGS, que as bibliotecas vêm depois dos arquivos objeto, e que cada .o lista como pré-requisitos o seu .c e os .h que ele inclui. A barra invertida no fim de uma linha continua a definição na linha seguinte. Para outro projeto, basta trocar o nome do executável e as regras dos arquivos objeto.

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

main.o: Aluno.h
Aluno.o: Aluno.h

Exercícios

Encontre o erro

O executor desta página não roda o make, então os exercícios abaixo mostram o Makefile e o que aconteceu ao usá-lo. Em todos, o projeto é o TAD Aluno ou o TAD Ponto, com os arquivos corretos.

Makefile 1

TADAluno: main.o Aluno.o
    gcc main.o Aluno.o -o TADAluno

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

Aluno.o: Aluno.c Aluno.h
    gcc -c Aluno.c

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

Makefile 2

CFLAGS = -std=c11 -Wall -Wextra

TADPonto: main.o Ponto.o
	gcc main.o Ponto.o -lm -o TADPonto

main.o: main.c
	gcc $(CFLAGS) -c main.c

Ponto.o: Ponto.c
	gcc $(CFLAGS) -c Ponto.c

O projeto compilou e funcionou. Depois, os parâmetros de criaPonto e de atribuiPonto mudaram de double para float, em Ponto.h e em Ponto.c:

$ make
gcc -std=c11 -Wall -Wextra -c Ponto.c
gcc main.o Ponto.o -lm -o TADPonto
$ ./TADPonto
Distancia: 0.0000
q = (0.0, 0.0), distancia: 0.0000

Depois de um rm -f *.o TADPonto e de um novo make, tudo volta a funcionar.

main.o: main.c Ponto.h
Ponto.o: Ponto.c Ponto.h

Makefile 3

Aluno.c tem um erro proposital: a->nome[MAX] = '\0'; escreve uma posição além do vetor nome.

CFLAGS  = -std=c11 -O0 -g -Wall -Wextra -Werror -Wshadow
LDFLAGS = -fsanitize=address,undefined
EXECUTAVEL = TADAluno

$(EXECUTAVEL): main.o Aluno.o
	gcc main.o Aluno.o $(LDFLAGS) -o $(EXECUTAVEL)

main.o: main.c Aluno.h
	gcc $(CFLAGS) -c main.c

Aluno.o: Aluno.c Aluno.h
	gcc $(CFLAGS) -c Aluno.c

run: $(EXECUTAVEL)
	./$(EXECUTAVEL)

$ make run
gcc -std=c11 -O0 -g -Wall -Wextra -Werror -Wshadow -c main.c
gcc -std=c11 -O0 -g -Wall -Wextra -Werror -Wshadow -c Aluno.c
gcc main.o Aluno.o -fsanitize=address,undefined -o TADAluno
./TADAluno
Nome: Maria | Matricula: 2024001 | CR: 8.50
Nome: Maria | Matricula: 2024001 | CR: 10.00

Por que o erro não foi detectado?

Aluno.c:29:12: runtime error: index 50 out of bounds for type 'char [50]'

Makefile 4

O mesmo projeto, agora com a flag só em CFLAGS:

CFLAGS  = -std=c11 -O0 -g -Wall -Wextra -Werror -Wshadow -fsanitize=address,undefined
EXECUTAVEL = TADAluno

$(EXECUTAVEL): main.o Aluno.o
	gcc main.o Aluno.o -o $(EXECUTAVEL)

main.o: main.c Aluno.h
	gcc $(CFLAGS) -c main.c

Aluno.o: Aluno.c Aluno.h
	gcc $(CFLAGS) -c Aluno.c

$ make
gcc -std=c11 -O0 -g -Wall -Wextra -Werror -Wshadow -fsanitize=address,undefined -c main.c
gcc -std=c11 -O0 -g -Wall -Wextra -Werror -Wshadow -fsanitize=address,undefined -c Aluno.c
gcc main.o Aluno.o -o TADAluno
/usr/bin/ld: main.o: in function `_sub_D_00099_0':
main.c:15:(.text+0x8b): undefined reference to `__asan_unregister_globals'
...
collect2: error: ld returned 1 exit status
make: *** [Makefile:5: TADAluno] Error 1

Makefile 5

Os arquivos objeto já estão compilados. Falta ligar.

TADPonto: main.o Ponto.o
	gcc -lm main.o Ponto.o -o TADPonto

$ make
gcc -lm main.o Ponto.o -o TADPonto
/usr/bin/ld: Ponto.o: in function `distanciaPonto':
Ponto.c:(.text+0x15d): undefined reference to `sqrt'
collect2: error: ld returned 1 exit status

Referências

• GNU make. Manual oficial.
• Overall Options (-c, -o, -E). Documentação do gcc.