How do I make a simple makefile for gcc on Linux?

simple makefile c
makefile for c program in linux
gcc makefile
makefile include path
makefile missing separator
java makefile
makefile template
how to run makefile in c

I have three files: program.c, program.h and headers.h.

program.c includes program.h and headers.h.

I need to compile this on Linux using gcc compiler. I'm not sure how to do this. Netbeans created one for me, but it's empty.

Interesting, I didn't know make would default to using the C compiler given rules regarding source files.

Anyway, a simple solution that demonstrates simple Makefile concepts would be:

HEADERS = program.h headers.h

default: program

program.o: program.c $(HEADERS)
    gcc -c program.c -o program.o

program: program.o
    gcc program.o -o program

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

(bear in mind that make requires tab instead of space indentation, so be sure to fix that when copying)

However, to support more C files, you'd have to make new rules for each of them. Thus, to improve:

HEADERS = program.h headers.h
OBJECTS = program.o

default: program

%.o: %.c $(HEADERS)
    gcc -c $< -o $@

program: $(OBJECTS)
    gcc $(OBJECTS) -o $@

clean:
    -rm -f $(OBJECTS)
    -rm -f program

I tried to make this as simple as possible by omitting variables like $(CC) and $(CFLAGS) that are usually seen in makefiles. If you're interested in figuring that out, I hope I've given you a good start on that.

Here's the Makefile I like to use for C source. Feel free to use it:

TARGET = prog
LIBS = -lm
CC = gcc
CFLAGS = -g -Wall

.PHONY: default all clean

default: $(TARGET)
all: default

OBJECTS = $(patsubst %.c, %.o, $(wildcard *.c))
HEADERS = $(wildcard *.h)

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

.PRECIOUS: $(TARGET) $(OBJECTS)

$(TARGET): $(OBJECTS)
    $(CC) $(OBJECTS) -Wall $(LIBS) -o $@

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

It uses the wildcard and patsubst features of the make utility to automatically include .c and .h files in the current directory, meaning when you add new code files to your directory, you won't have to update the Makefile. However, if you want to change the name of the generated executable, libraries, or compiler flags, you can just modify the variables.

In either case, don't use autoconf, please. I'm begging you! :)

How do I make a simple makefile for gcc on Linux?, Interesting, I didn't know make would default to using the C compiler given rules regarding source files. Anyway, a simple solution that� How to implement Makefile: 1. Installing GCC. Step 1: Open terminal in your linux machine. Now type : sudo apt install gcc. It will install gcc. Step 2: Now type. sudo apt install build-essential. Your GCC is ready in your Linux Machine. 2. Creating .c files. We have to create some C files which we need to compile using GCC and make using terminal window. Step1: Type gedit in terminal.

For example this simple Makefile should be sufficient:

CC=gcc 
CFLAGS=-Wall

all: program
program: program.o
program.o: program.c program.h headers.h

clean:
    rm -f program program.o
run: program
    ./program

Note there must be <tab> on the next line after clean and run, not spaces.

UPDATE Comments below applied

Using make and writing Makefiles, A complete reference for writing makefiles from simple to advanced features. makedepend can be run on a Makefile (with a special line at the bottom) to� Here is a straightforward makefile that describes the way an executable file called edit depends on eight object files which, in turn, depend on eight C source and three header files. In this example, all the C files include defs.h , but only those defining editing commands include command.h , and only low level files that change the editor

all: program
program.o: program.h headers.h

is enough. the rest is implicit

Simple Makefile (GNU make), 2.2 A Simple Makefile. Here is a straightforward makefile that describes the way an executable file called edit depends on eight object files which, in turn,� How to Create and Run Simple makefile? [Example] hellomake: hellomake.c hellofunc.c gcc -o hellomake hellomake.c hellofunc.c -I. Save this file as makefile or Makefile. When you run the command make in the same directory where the makefile is located, it compiles the file in the same order mentioned in the makefile rule. Here,

The simplest make file can be

all : test

test : test.o
        gcc -o test test.o 

test.o : test.c
        gcc -c test.c

clean :
        rm test *.o

GCC and Make, Richard Stallman founded the GNU project in 1984 to create a complete Alternatively, you could look for an online man pages, e.g., http://linux.die.net/ man/1/gcc. Create the following file named "makefile" (without any file extension), which� The host system is x64 GNU Linux. Here is the listing of my very simple makefile for a C program: CC=arm-linux-gcc CFLAGS=-Wall main: test.o clean: rm -f test test.o The makefile reproduced above only creates an object file with extension .o, and does not create an ELF binary.

Depending on the number of headers and your development habits, you may want to investigate gccmakedep. This program examines your current directory and adds to the end of the makefile the header dependencies for each .c/cpp file. This is overkill when you have 2 headers and one program file. However, if you have 5+ little test programs and you are editing one of 10 headers, you can then trust make to rebuild exactly those programs which were changed by your modifications.

What is a Makefile and how does it work?, Create a empty directory myproject containing a file Makefile with this content: For example, to assign the command gcc to a variable CC : user and likes to talk and write about open source, GNU/Linux, Git, and Python. GCC (GNU Compiler Collection) A Brief History and Introduction to GCC. The original GNU C Compiler (GCC) is developed by Richard Stallman, the founder of the GNU Project. Richard Stallman founded the GNU project in 1984 to create a complete Unix-like operating system as free software, to promote freedom and cooperation among computer users and

How to Create a Simple Makefile - Introduction to Makefiles, In this video I show how to create a simple makefile. Want to learn C++? I highly recommend Duration: 9:24 Posted: 18 May 2015 In order to fix this, we need to tell make that all .c files depend on certain .h files. We can do this by writing a simple rule and adding it to the makefile. Makefile 3 CC=gcc CFLAGS=-I. DEPS = hellomake.h %.o: %.c $(DEPS) $(CC) -c -o $@ $ $(CFLAGS) hellomake: hellomake.o hellofunc.o $(CC) -o hellomake hellomake.o hellofunc.o

A Simple Makefile Tutorial, A simple tutorial on how to use the makefile in console environment under Linux. The Duration: 7:04 Posted: 3 Feb 2015 Make has a whole host of built-in rules that mean that very often, a project can be compile by a very simple makefile, indeed. The GNU make built in rule for C source files is the one exhibited above. Similarly we create object files from C++ source files with a rule like $(CXX) -c $(CPPFLAGS) $(CFLAGS).

An Introduction to GCC - A simple makefile, c' files by compilation, and that an executable can be made by linking together '.o' files. Implicit rules are defined in terms of make variables, such as CC (the C� How do I make a simple makefile for gcc on Linux? (4) Depending on the number of headers and your development habits, you may want to investigate gccmakedep. This program examines your current directory and adds to the end of the makefile the header dependencies for each .c/cpp file.

Comments
  • There is an extremely elegant (and well documented) solution at spin.atomicobject.com/2016/08/26/makefile-c-projects.
  • To be technically correct, I believe you should use .PHONY: clean all default for those targets that are meant to be used from the command line. Also, Autoconf/Automake aren't that bad. Sure, they feel awful, and getting used to them is about as fun as forcing your head through a brick wall, but they do work, and they're well developed, and they'll cover most of your bases as far as portability, and will make your life a lot easier in the end once you get used to their awful design.
  • I guess this works, but I thought if I typed "make" on the terminal the program should run. This is what I get: gcc statsh.o -Wall -lm -o prog Is it possible to just type make and execute the program?
  • where would you add the openmp flag -fopenmp
  • Why don't use autoconf joey-adams ?
  • If anyone wonders why there are dashes in front of rm: stackoverflow.com/questions/2989465/rm-rf-versus-rm-rf
  • @user69514: make with no arguments usually only build your software. To run it, either use make run (available in this answer, but not necessarily in all Makefiles), or run it directly: ./program
  • And if your whole program is a single .c file, only program: is necessary. Sweet :)
  • you can add more detail to explain what your Makefile does
  • you can actually go a lot simpler. see @anonymous 1 liner