Clang

clang [options] input.c -o output
clang++ [options] input.cpp -o output

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

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

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

// hello.cpp
#include <iostream>

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

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

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

source.c -> preprocessed source -> LLVM/assembly -> object file -> executable
             preprocessing          compilation      assemble      link

clang -E hello.c -o hello.i              # Preprocess only
clang -S hello.c -o hello.s              # Assembly
clang -S -emit-llvm hello.c -o hello.ll  # Text LLVM IR
clang -c hello.c -o hello.o              # Object file
clang hello.o -o hello                   # Link executable

clang -save-temps hello.c -o hello

clang -std=c17 -O0 -S -emit-llvm main.c -o main_O0.ll
clang -std=c17 -O2 -S -emit-llvm main.c -o main_O2.ll

#if defined(DEBUG)
fprintf(stderr, "count = %d\n", count);
#endif

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

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

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

# Continuous integration: warnings fail the build
clang -std=c17 -Wall -Wextra -Wpedantic -Werror main.c -o app

clang -Weverything main.c -o app

clang -fcolor-diagnostics main.c -o app
clang -fdiagnostics-show-option main.c -o app
clang -ferror-limit=5 main.c -o app

clang -std=c17 -Wall -Wextra -Wpedantic -g -O0 main.c -o app
lldb ./app

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

lldb ./app

(lldb) breakpoint set --name main
(lldb) run
(lldb) next
(lldb) step
(lldb) frame variable
(lldb) backtrace

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

./app

clang -g -O1 -fsanitize=undefined -fno-sanitize-recover=undefined main.c -o app

clang -g -O1 \
  -fsanitize=implicit-integer-truncation,implicit-integer-sign-change \
  main.c -o app

clang --analyze main.c

scan-build make
scan-build cmake --build build

clang-tidy src/main.cpp -- -std=c++20 -Iinclude
clang-tidy src/main.cpp -checks='bugprone-*,performance-*' -- -std=c++20 -Iinclude

clang-tidy -p build src/main.cpp

cmake -S . -B build -DCMAKE_EXPORT_COMPILE_COMMANDS=ON
clang-tidy -p build src/main.cpp

clang-format -i src/main.c
clang-format -i src/*.cpp include/*.hpp

clang-format -style=llvm -dump-config > .clang-format

clang-format -i -style=file src/main.cpp

clang-format src/main.cpp
clang-format --dry-run --Werror src/main.cpp

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

# One command
clang -std=c17 -Wall -Wextra -Iinclude \
  src/main.c src/math_utils.c -o app

# Separate compilation
clang -std=c17 -Wall -Wextra -Iinclude -c src/main.c -o main.o
clang -std=c17 -Wall -Wextra -Iinclude -c src/math_utils.c -o math_utils.o
clang main.o math_utils.o -o app

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

clang main.c -lm -o app          # Math library on Unix-like systems
clang main.c -pthread -o app     # POSIX threading where supported
clang main.o -Llib -lshape -o app

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

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

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

clang++ -std=c++20 main.cpp -stdlib=libc++ -o app

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

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

clang -O2 -flto -fuse-ld=lld main.o util.o -o app

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

# 1. Build with coverage instrumentation
clang -std=c17 -O0 -g \
  -fprofile-instr-generate -fcoverage-mapping \
  main.c -o app

# 2. Run tests or representative workloads
LLVM_PROFILE_FILE="app.profraw" ./app

# 3. Merge the raw profile
llvm-profdata merge -sparse app.profraw -o app.profdata

# 4. View summaries or annotated source
llvm-cov report ./app -instr-profile=app.profdata
llvm-cov show ./app -instr-profile=app.profdata

llvm-cov show ./app -instr-profile=app.profdata \
  -format=html -output-dir=coverage-html

LLVM_PROFILE_FILE="profiles/app-%p.profraw" ./app test-input-1
LLVM_PROFILE_FILE="profiles/app-%p.profraw" ./app test-input-2
llvm-profdata merge -sparse profiles/*.profraw -o app.profdata
llvm-cov report ./app -instr-profile=app.profdata

# 1. Instrument
clang -O2 -fprofile-instr-generate main.c -o app

# 2. Run representative workloads
LLVM_PROFILE_FILE="app.profraw" ./app input.txt

# 3. Convert runtime profile data
llvm-profdata merge app.profraw -o app.profdata

# 4. Optimize with profile feedback
clang -O2 -fprofile-instr-use=app.profdata main.c -o app

clang -E -Iinclude src/main.c -o main.i
clang -dM -E -x c /dev/null             # Predefined C macros on Unix

'' | clang -std=c17 -dM -E -x c -

clang -H -Iinclude -c src/main.c
clang -v -E -x c /dev/null              # Include search paths on Unix

clang -Xclang -ast-dump -fsyntax-only main.c
clang++ -std=c++20 -Xclang -ast-dump -fsyntax-only main.cpp

clang -O2 -S -emit-llvm main.c -o main.ll
clang -O2 -Rpass=inline main.c -o app
clang -O2 -Rpass-missed=inline main.c -o app

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

int add(int a, int b);

#ifdef __cplusplus
}
#endif

clang -print-target-triple
clang --target=aarch64-linux-gnu -c main.c -o main.o
clang --target=x86_64-w64-windows-gnu main.c -o app.exe

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

clang -O2 -fcf-protection=full main.c -o app

CC := clang
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 coverage 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)

coverage: CFLAGS += -O0 -g -fprofile-instr-generate -fcoverage-mapping
coverage: LDFLAGS += -fprofile-instr-generate -fcoverage-mapping
coverage: $(TARGET)

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

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

clean:
	rm -f $(TARGET) $(OBJECTS) $(DEPENDS) *.profraw *.profdata

-include $(DEPENDS)

make debug
make clean
make release
make clean
make coverage
LLVM_PROFILE_FILE="app.profraw" ./app
llvm-profdata merge -sparse app.profraw -o app.profdata
llvm-cov report ./app -instr-profile=app.profdata

# Good for traditional static link resolution
clang main.o -L. -lutils -lm -o app

# Can fail because referenced symbols appear after libraries
clang -lutils -lm main.o -o app

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

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

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

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

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

clang -std=c17 -O2 -S -emit-llvm main.c -o main.ll

clang --analyze main.c
clang-format -i main.c

clang -O0 -g -fprofile-instr-generate -fcoverage-mapping main.c -o app
LLVM_PROFILE_FILE="app.profraw" ./app
llvm-profdata merge -sparse app.profraw -o app.profdata
llvm-cov report ./app -instr-profile=app.profdata

Build C:       clang -std=c17 -Wall -Wextra file.c -o app
Build C++:     clang++ -std=c++20 -Wall -Wextra file.cpp -o app
Compile only:  clang -c file.c -o file.o
Link:          clang main.o util.o -lm -o app
Debug:         clang -g -Og file.c -o app
Sanitize:      clang -g -O1 -fsanitize=address,undefined file.c -o app
Release:       clang -O2 -DNDEBUG file.c -o app
Preprocess:    clang -E file.c -o file.i
LLVM IR:       clang -S -emit-llvm file.c -o file.ll
Analyze:       clang --analyze file.c
Format:        clang-format -i file.c
Coverage:      clang -fprofile-instr-generate -fcoverage-mapping file.c -o app