GCC

gcc [options] input.c -o output
g++ [options] input.cpp -o output

// hello.c
#include <stdio.h>

int main(void) {
    puts("Hello, GCC!");
    return 0;
}

gcc hello.c -o hello       # Compile and link
./hello                    # Run on Linux/macOS

// hello.cpp
#include <iostream>

int main() {
    std::cout << "Hello, GCC!\n";
}

g++ hello.cpp -o hello     # Use g++ for C++ linking
./hello

gcc -std=c17 -Wall -Wextra -Wpedantic -g main.c -o app

source.c -> preprocessed source -> assembly -> object file -> executable
             preprocessing          compile       assemble      link

gcc -E hello.c -o hello.i   # Stop after preprocessing
gcc -S hello.c -o hello.s   # Stop after generating assembly
gcc -c hello.c -o hello.o   # Stop after object file
gcc hello.o -o hello        # Link object into executable

gcc -save-temps hello.c -o hello

#ifdef DEBUG
fprintf(stderr, "x = %d\n", x);
#endif

gcc -DDEBUG -Iinclude src/main.c -o app

# Everyday C development
gcc -std=c17 -Wall -Wextra -Wpedantic -Wconversion -Wshadow main.c -o app

# Everyday C++ development
g++ -std=c++20 -Wall -Wextra -Wpedantic -Wconversion -Wshadow main.cpp -o app

# Continuous integration: reject newly introduced warnings
gcc -std=c17 -Wall -Wextra -Wpedantic -Werror main.c -o app

gcc -fdiagnostics-color=always -fdiagnostics-show-option main.c -o app
gcc -fmax-errors=5 main.c -o app

gcc -std=c17 -Wall -Wextra -Wpedantic -g -O0 main.c -o app
gdb ./app

gcc -std=c17 -Wall -Wextra -g3 -Og -fno-omit-frame-pointer main.c -o app

gdb ./app                         # Interactive debugger
gcc -E main.c | less              # Inspect expanded macros/includes
gcc -S -fverbose-asm main.c       # Assembly with compiler comments
gcc -H -c main.c                  # Print included header hierarchy

gcc -std=c17 -Wall -Wextra -g -Og \
  -fsanitize=address,undefined -fno-omit-frame-pointer \
  main.c -o app

./app

gcc -std=c17 -Wall -Wextra -fanalyzer -c main.c

project/
  include/math_utils.h
  src/main.c
  src/math_utils.c

# One command: compile and link everything
gcc -std=c17 -Wall -Wextra -Iinclude \
  src/main.c src/math_utils.c -o app

# Separate compilation: rebuild only changed files
gcc -std=c17 -Wall -Wextra -Iinclude -c src/main.c -o main.o
gcc -std=c17 -Wall -Wextra -Iinclude -c src/math_utils.c -o math_utils.o
gcc main.o math_utils.o -o app

gcc -std=c17 -Wall -Wextra -MMD -MP -Iinclude -c src/main.c -o main.o

gcc main.c -lm -o app       # Link libm for functions such as sqrt() on Unix-like systems
gcc main.c -pthread -o app  # Compile/link POSIX threads where supported

gcc main.o geometry.o -Llib -lshape -lm -o app

gcc -std=c17 -O2 -Iinclude -c src/math_utils.c -o math_utils.o
ar rcs libmathutils.a math_utils.o
gcc main.o -L. -lmathutils -o app

gcc -std=c17 -O2 -fPIC -Iinclude -c src/math_utils.c -o math_utils.o
gcc -shared math_utils.o -o libmathutils.so
gcc main.o -L. -lmathutils -Wl,-rpath,'$ORIGIN' -o app

gcc -std=c17 -O2 -DNDEBUG -Wall -Wextra main.c -o app

gcc -std=c17 -O2 -flto -c main.c -o main.o
gcc -std=c17 -O2 -flto -c util.c -o util.o
gcc -O2 -flto main.o util.o -o app

gcc -O2 -march=native main.c -o app

gcc -std=c17 -O0 -g --coverage main.c -o app
./app
gcov main.c

# 1. Build an instrumented program
gcc -O2 -fprofile-generate main.c -o app

# 2. Run realistic workloads
./app input.txt

# 3. Rebuild using measured behavior
gcc -O2 -fprofile-use main.c -o app

gcc -DDEBUG -DLOG_LEVEL=2 main.c -o debug_app
gcc -DNDEBUG -DAPP_VERSION='"1.2.0"' main.c -o release_app

#if defined(DEBUG)
    #define LOG(message) fprintf(stderr, "%s\n", message)
#else
    #define LOG(message) ((void)0)
#endif

gcc -dM -E - < /dev/null              # Unix shell: built-in C macros
gcc -std=c17 -dM -E - < /dev/null    # Include selected standard mode

'' | gcc -std=c17 -dM -E -

gcc -E -Iinclude src/main.c -o main.i
gcc -v -E -x c /dev/null             # Print configured include search paths on Unix
gcc -H -Iinclude -c src/main.c       # Trace headers being included

g++ -std=c++20 main.cpp widget.cpp -o app

/* math_api.h */
#ifdef __cplusplus
extern "C" {
#endif

int add(int a, int b);

#ifdef __cplusplus
}
#endif

gcc -std=c17 -O2 -Wall -Wextra \
  -fstack-protector-strong -D_FORTIFY_SOURCE=2 \
  -fPIE -pie main.c -o app

gcc --help=warnings
gcc --help=optimizers
gcc --help=target
gcc -Q -O2 --help=optimizers

gcc -std=c17 -O2 -S main.c -o main.s
gcc -std=c17 -O2 -S -masm=intel main.c -o main.s  # Supported on x86 targets
gcc -std=c17 -O2 -fverbose-asm -S main.c -o main.s

nm app                  # List symbols
objdump -d app          # Disassemble
readelf -h app          # ELF header information
ldd app                 # Shared library dependencies on Linux

CC := gcc
CPPFLAGS := -Iinclude
CFLAGS := -std=c17 -Wall -Wextra -Wpedantic -MMD -MP
LDLIBS :=

TARGET := app
SOURCES := src/main.c src/math_utils.c
OBJECTS := $(SOURCES:.c=.o)
DEPENDS := $(OBJECTS:.o=.d)

.PHONY: all debug release clean

all: debug

debug: CFLAGS += -g -Og -fsanitize=address,undefined -fno-omit-frame-pointer
debug: LDFLAGS += -fsanitize=address,undefined
debug: $(TARGET)

release: CFLAGS += -O2 -DNDEBUG
release: $(TARGET)

$(TARGET): $(OBJECTS)
	$(CC) $(LDFLAGS) $^ $(LDLIBS) -o $@

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

clean:
	rm -f $(TARGET) $(OBJECTS) $(DEPENDS)

-include $(DEPENDS)

make debug
make clean
make release

# Good: objects first, dependent libraries later
gcc main.o -L. -lutils -lm -o app

# Can fail with traditional static linking order
gcc -lutils -lm main.o -o app

gcc -std=c17 -Wall -Wextra -Wpedantic -Wconversion -g -Og main.c -o app

gcc -std=c17 -Wall -Wextra -g -Og \
  -fsanitize=address,undefined -fno-omit-frame-pointer \
  main.c -o app

gcc -std=c17 -Wall -Wextra -O2 -DNDEBUG main.c -o app

g++ -std=c++20 -Wall -Wextra -Wpedantic -g -Og main.cpp -o app

gcc -std=c17 -Wall -Wextra -Iinclude \
  src/main.c src/io.c src/math_utils.c -o app

gcc -std=c17 -Wall -Wextra -Iinclude -c src/io.c -o io.o
gcc -std=c17 -Wall -Wextra -Iinclude -c src/main.c -o main.o
gcc main.o io.o -o app

Build C:       gcc -std=c17 -Wall -Wextra file.c -o app
Build C++:     g++ -std=c++20 -Wall -Wextra file.cpp -o app
Compile only:  gcc -c file.c -o file.o
Link:          gcc main.o util.o -lm -o app
Debug:         gcc -g -Og file.c -o app
Sanitize:      gcc -g -Og -fsanitize=address,undefined file.c -o app
Release:       gcc -O2 -DNDEBUG file.c -o app
Preprocess:    gcc -E file.c -o file.i
Assembly:      gcc -O2 -S file.c -o file.s
Coverage:      gcc --coverage file.c -o app && ./app && gcov file.c