Comprensión simple de Makefile 1
Hay muchos artículos sobre el aprendizaje de Makefile en Internet, y cada artículo tiene sus propias características. Solo para mí, sigo sintiendo que algunos problemas no están claros. Ahora quiero analizar desde una perspectiva de base cero y aprender Makefile con todos.
Con todo, ¡es para simplificar problemas complejos!
[Introducción a la función] MakeFile puede considerarse como un lenguaje de programación simple, el propósito esencial de su nacimiento es realizar la compilación automática.
Tomando el compilador gcc-c en Linux como ejemplo, compilar un programa en lenguaje C requiere los siguientes pasos:
1. Preprocesamiento para generar archivos precompilados (archivos .i):
gcc -E hello.c -o hello.i
2. Compilación para generar código ensamblador (archivos .s):
gcc -S hello.i -o hello .s
3. Ensamblar (Ensamblar), generar archivo objeto (archivo .o):
gcc -c hola.s -o hola.o
4. Enlace (Enlace), generar archivo ejecutable:
gcc hola. o –o hola
Si quieres completar todo el proceso en un solo paso:
gcc hello.c -o hello
[Compilación y vinculación]
Para obtener el programa ejecutable final, primero debe compilar el archivo fuente en un archivo de código intermedio, que es un archivo .obj en Windows, y un archivo .o en UNIX \ Linux, a saber, archivo de objeto, compilar ( compilar). Luego combine una gran cantidad de archivos de objeto en archivos ejecutables y vincúlelos.
Al compilar, lo que necesita el compilador es una sintaxis correcta y una declaración correcta de funciones y variables. Para este último, normalmente necesita decirle al compilador dónde están los archivos de encabezado. Siempre que toda la sintaxis sea correcta, el compilador puede compilar archivos de objetos intermedios. En términos generales, cada archivo de origen debe corresponder a un archivo de destino intermedio (archivo O o archivo OBJ).
[Método de trabajo] Archivo Makefile
.C archivo -> archivo .o -> archivo ejecutable
Si desea especificar un Makefile específico, puede usar los parámetros "-f" y "-file" de make, como: make -f Makefile o make --file Makefile
[Ejemplo de introducción] Programa MakeFile de Hello
TOPDIR = ../
include $(TOPDIR)Rules.mak
EXTRA_LIBS +=
EXEC = $(INSTALL_DIR)/hello
OBJS = hello.o
all: $(EXEC)
$(EXEC): $(OBJS)
$(CC) $(LDFLAGS) -o $@ $(OBJS) $(EXTRA_LIBS)
install:
$(EXP_INSTALL) $(EXEC) $(INSTALL_DIR)
clean:
-rm -f $(EXEC) *.elf *.gdb *.o
[Explicación]
CC especifica la macro del compilador
EXEC representa la macro del nombre del archivo ejecutable generado
Macro de lista de archivos de objetos OBJS
Macro de parámetro de conexión LDFLAGS
Todo: compila la entrada principal
Limpiar: borra los resultados de la compilación
Instalar: instale el archivo ejecutable compilado correctamente en el directorio del sistema, generalmente el directorio / usr / local / bin
[Reglas de Makefile]
Hay principalmente cinco cosas en el Makefile:
reglas explícitas,
reglas implícitas,
definiciones de variables,
instrucciones de archivo,
comentarios
1. Reglas explícitas.
Las reglas explícitas explican cómo generar uno o más archivos de objeto. Esto lo señala claramente el escritor del Makefile, los archivos que se generarán, los archivos dependientes de los archivos y los comandos generados.
Tales como: foo.o: foo.c defs.h relación de dependencia
gcc -o foo.o foo.c El método (método) de generar el objetivo
2. Reglas implícitas.
Dado que nuestro make tiene la función de derivación automática, las reglas oscuras nos permiten escribir Makefile de manera más cruda y concisa, lo que es compatible con make.
Como: foo.o: foo.c (El archivo .o en sí deriva el archivo dependiente con el mismo nombre.c.)
3. La definición de variables.
En el Makefile, necesitamos definir una serie de variables. Las variables son generalmente cadenas. Esto es un poco como una macro en el lenguaje C. Cuando se ejecuta el Makefile, las variables en él se expandirán a las posiciones de referencia correspondientes.
Tales como: H: = foo.c gcc -o foo.o $ (H) (La asignación puede usar: = o directamente =)
4. Archivo de instrucciones.
Incluye tres partes, una es hacer referencia a otro Makefile en un Makefile, al igual que el include en lenguaje C; la otra es especificar la parte efectiva del Makefile de acuerdo con ciertas circunstancias, al igual que la precompilación en lenguaje C # si es lo mismo ; otro es definir un comando multilínea.
5. Notas.
Solo hay comentarios de línea en el Makefile, que es lo mismo que el script de UNIX Shell. Los comentarios usan el carácter "#", que es como el "//" en C / C ++ y Java.
Los comandos en el Makefile deben comenzar con la tecla [Tab].