Common Makefile Templates for Linux Development

Introduction

For development on Windows, many IDEs integrate compilers, such as Visual Studio, providing a “one-click compile” feature, allowing you to compile, link, and generate target files with a single action after coding.

Linux development differs from Windows; generally, the gcc/g++ compiler is used on Linux. If developing Linux programs for ARM, the arm-linux-gcc/arm-linux-g++ cross-compiler is also needed.

Linux can also achieve a “one-click compile” function, which requires a compilation script called “Makefile”. Makefiles can be manually written or generated with automation build tools (like scons, CMake). Writing Makefiles manually is one of the distinctions between Linux and Windows programmers. Generally, a universal Makefile can suit most Linux project programs.

Three Makefile Templates

2.1 Makefile for Compiling Executable Files

VERSION  =1.00
CC   =gcc
DEBUG   =-DUSE_DEBUG
CFLAGS  =-Wall
SOURCES   =$(wildcard ./source/*.c)
INCLUDES   =-I./include
LIB_NAMES  =-lfun_a -lfun_so
LIB_PATH  =-L./lib
OBJ   =$(patsubst %.c, %.o, $(SOURCES))
TARGET  =app

#links
$(TARGET):$(OBJ)
 @mkdir -p output
 $(CC) $(OBJ) $(LIB_PATH) $(LIB_NAMES) -o output/$(TARGET)$(VERSION)
 @rm -rf $(OBJ)
 
#compile
%.o: %.c
 $(CC) $(INCLUDES) $(DEBUG) -c $(CFLAGS) $< -o $@

.PHONY:clean
clean:
 @echo "Remove linked and compiled files......"
 rm -rf $(OBJ) $(TARGET) output 

【Key Points】

【1】Program Version

Multiple program versions may be generated during the development and debugging process; you can add a version number identifier after (or before) the target file.

VERSION = 1.00
$(CC) $(OBJ) $(LIB_PATH) $(LIB_NAMES) -o output/$(TARGET)$(VERSION)

【2】Compiler Selection

On Linux, it is gcc/g++; for ARM, it is arm-linux-gcc; different CPU vendors may provide custom cross-compiler names, such as Hisilicon’s “arm-hisiv300-linux-gcc”.

CC = gcc

【3】Macro Definitions

During the development process, special codes generally add macro conditions to decide whether to compile, such as debugging print output codes. -D is the identifier, followed by the “macro”.

DEBUG =-DUSE_DEBUG

【4】Compilation Options

You can specify compilation conditions, such as showing warnings (-Wall) and optimization levels (-O).

CFLAGS =-Wall -O

【5】Source Files

Specify the destination path for source files, utilizing “wildcard” to get all dependent source files in the path.

SOURCES =$(wildcard ./source/*.c)

【6】Header Files

Include the required header files, including those for source files and library files.

INCLUDES =-I./include

【7】Library File Names

Specify the library file names; library files have a fixed format, static libraries as libxxx.a; dynamic libraries as libxxx.so, and you only need to write the “xxx” part for the library file names.

LIB_NAMES =-lfun_a -lfun_so

【8】Library File Paths

Specify the storage path for the dependent library files. Note that if a dynamic library is referenced, it may be copied to the “/lib” or “/usr/lib” directories, and the system defaults to indexing dynamic libraries from these paths when executing applications.

LIB_PATH =-L./lib

【9】Target Files

Call “patsubst” to compile source files (.c) to target files (.o).

OBJ =$(patsubst %.c, %.o, $(SOURCES))

【10】Executable Files

Name of the executable file

TARGET =app

【11】Compilation

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

【12】Linking

You can create an “output” folder to store the target executable files. After linking and outputting the target executable file, you can delete the temporary files generated during compilation (.o).

$(TARGET):$(OBJ)
 @mkdir -p output
 $(CC) $(OBJ) $(LIB_PATH) $(LIB_NAMES) -o output/$(TARGET).$(VERSION)
 @rm -rf $(OBJ)

【13】Clear Compilation Information

Execute “make clean” to clear the temporary files generated during compilation.

.PHONY:clean
clean:
 @echo "Remove linked and compiled files......"
 rm -rf $(OBJ) $(TARGET) output 

2.2 Makefile for Compiling Static Libraries

VERSION     =
CC          =gcc
DEBUG   =
CFLAGS  =-Wall
AR   =ar
ARFLAGS     =rv
SOURCES   =$(wildcard *.c)
INCLUDES    =-I.
LIB_NAMES   =
LIB_PATH  =
OBJ         =$(patsubst %.c, %.o, $(SOURCES))
TARGET      =libfun_a

#link
$(TARGET):$(OBJ)
 @mkdir -p output
 $(AR) $(ARFLAGS) output/$(TARGET)$(VERSION).a $(OBJ)
 @rm -rf $(OBJ)

#compile
%.o: %.c
 $(CC) $(INCLUDES) $(DEBUG) -c $(CFLAGS) $< -o $@
  
.PHONY:clean
clean:
 @echo "Remove linked and compiled files......"
 rm -rf $(OBJ) $(TARGET) output 

【Key Points】

The basic format is consistent with the “Makefile for Compiling Executable Files”; the differences include the following.

【1】Use the “ar” command to link target files (.o) into static library files (.a). The fixed naming format for static library files is: libxxx.a.

2.3 Makefile for Compiling Dynamic Libraries

VERSION   =
CC        =gcc
DEBUG     =
CFLAGS    =-fPIC -shared 
LFLAGS   =-fPIC -shared 
SOURCES   =$(wildcard *.c)
INCLUDES  =-I.
LIB_NAMES =
LIB_PATH  =
OBJ       =$(patsubst %.c, %.o, $(SOURCES))
TARGET    =libfun_so

#link
$(TARGET):$(OBJ)
 @mkdir -p output
 $(CC) $(OBJ) $(LIB_PATH) $(LIB_NAMES) $(LFLAGS) -o output/$(TARGET)$(VERSION).so
 @rm -rf $(OBJ)
 
#compile
%.o: %.c
 $(CC) $(INCLUDES) $(DEBUG) -c $(CFLAGS) $< -o $@

.PHONY:clean
clean:
 @echo "Remove linked and compiled files......"
 rm -rf $(OBJ) $(TARGET) output 

【Key Points】

The basic format is consistent with the “Makefile for Compiling Executable Files”; the differences include the following.

【1】Compilation and linking options increase the “-fPIC -shared” options. The fixed naming format for dynamic library files is libxxx.so.

Demo

3.1 Compiling an Application

Write a test routine with the file storage directory structure as follows: header files stored in the “include” directory, library files in the “lib” directory, source files in the “source” directory, and the Makefile in the current directory.

Source Code 1:

/*Header File*/
#ifndef _FUN0_H_
#define _FUN0_H_
#endif

extern void fun0_printf(void);
extern void fun1_printf(void);

/*Source File*/
#include <stdio.h>
#include "fun0.h"

void fun0_printf(void)
{
    printf("Call 'fun0'. \r\n");
}

Source Code 2:

/*Header File*/
#ifndef _FUN1_H_
#define _FUN1_H_
#endif

extern void fun1_printf(void);

/*Source File*/
#include <stdio.h>
#include "fun1.h"

void fun1_printf(void)
{
    printf("Call 'fun1'.\r\n");
}

Main Function Source Code:

/*Source File*/
#include <stdio.h>
#include "fun0.h"
#include "fun1.h"
#include "fun_lib_a.h"
#include "fun_lib_so.h"

int main(void)
{
    #ifdef USE_DEBUG
        printf("Debug Application startup.\r\n");
    #endif
    
        fun0_printf();
        fun1_printf();
        fun_lib_a_printf();
        fun_lib_so_printf();
        return 0;
}

Library files, two library files stored in the “./lib” directory, one static library libfun_a.a and one dynamic library libfun_so.so.

The Makefile file is the “Makefile template from section 2.1”.

Test Run:

【If the executable file prompts that there is no “libfun_so.so”, copy “libfun_so.so” to the root directory’s “/lib” or “/usr/lib” directory because the system executes the program and defaults to pulling dynamic libraries from this path】

3.2 Generating a Static Library

Write a test routine, and the generated library file is the library file (libfun_a.a) called in “3.1”. The file storage directory structure is as follows:

Source Code:

/*Header File*/
#ifndef _FUN_LIB_A_H_
#define _FUN_LIB_A_H_
#endif

extern void fun_lib_a_printf(void);

/*Source File*/
#include <stdio.h>
#include "fun_lib_a.h"

void fun_lib_a_printf(void)
{
    printf("Call 'fun_lib_a'.\r\n");
}

The Makefile file is the “Makefile template from section 2.2”.

Compile to generate a static library:

3.3 Generating a Dynamic Library

Write a test routine, and the generated library file is the library file (libfun_so.so) called in “3.1”. The file storage directory structure is as follows:

Source Code:

/*Header File*/
#ifndef _FUN_LIB_SO_H_
#define _FUN_LIB_SO_H_
#endif

extern void fun_lib_so_printf(void);

/*Source File*/
#include <stdio.h>
#include "fun_lib_so.h"

void fun_lib_so_printf(void)
{
    printf("Call 'fun_lib_so'.\r\n");
}

Compile to generate a dynamic library: