> GCC & CLANG / LLVM REFERENCE

# Compilare ed eseguire un file C
gcc main.c -o prog
clang main.c -o prog

# Compilare C++
g++ main.cpp -o prog
clang++ main.cpp -o prog

# Multifile
gcc main.c utils.c io.c -o prog

# Compilazione separata (object files + linking)
gcc -c main.c              # produce main.o
gcc -c utils.c             # produce utils.o
gcc main.o utils.o -o prog # linking

# Aggiungere directory di include
gcc -I./include -I/usr/local/include main.c -o prog

# Linkare librerie
gcc main.c -L/usr/local/lib -lm -lpthread -o prog

# Include di sistema vs. locali
gcc -isystem /opt/sdk/include main.c  # sopprime warning da queste header

# Conformità stretta (disabilita estensioni)
gcc -std=c17 -pedantic main.c

# Estensioni GNU esplicite
gcc -std=gnu17 main.c

# Modalità freestanding (no hosted environment)
gcc -ffreestanding -nostdlib kernel.c -o kernel.bin

# Definire macro
gcc -DDEBUG main.c                     # #define DEBUG 1
gcc -DVERSION=3 main.c                # #define VERSION 3
gcc -DMSG='"hello"' main.c             # #define MSG "hello"

# Rimuovere macro predefinita
gcc -UNDEBUG main.c

# Solo output preprocessato
gcc -E main.c -o main.i

# Visualizzare macro predefinite
gcc -dM -E -x c /dev/null

# Generare dipendenze per Makefile
gcc -M main.c                          # tutte le dipendenze
gcc -MM main.c                         # solo dipendenze non-sistema
gcc -MMD main.c                        # compila E genera .d file

# GCC: generare e usare PCH
gcc common.h                            # produce common.h.gch
gcc main.c -o prog                    # usa common.h.gch automaticamente se #include "common.h"

# Clang: generare e usare PCH (esplicito)
clang -x c-header common.h -o common.h.pch
clang -include-pch common.h.pch main.c -o prog

# Generare LLVM IR leggibile
clang -S -emit-llvm main.c -o main.ll

# Generare LLVM bitcode
clang -c -emit-llvm main.c -o main.bc

# Convertire bitcode in IR leggibile
llvm-dis main.bc -o main.ll

# Compilare bitcode in object file
llc main.bc -o main.o -filetype=obj

# Assembly con sintassi Intel (default è AT&T)
gcc -S -masm=intel main.c -o main.s

# Assembly con annotazioni sorgente
gcc -S -g -fverbose-asm main.c -o main.s

# GCC: generare RTL (rappresentazione interna GCC)
gcc -fdump-rtl-expand main.c           # produce main.c.*.expand

# Creare una libreria condivisa
gcc -shared -fPIC utils.c -o libutils.so

# Creare una libreria statica
gcc -c utils.c
ar rcs libutils.a utils.o              # GNU ar (o llvm-ar)

# Linkare contro la libreria
gcc main.c -L. -lutils -Wl,-rpath,. -o prog

# Versioning della libreria condivisa (soname)
gcc -shared -fPIC -Wl,-soname,libutils.so.1 utils.c -o libutils.so.1.0

# Debug completo (disabilita ottimizzazioni per chiarezza)
gcc -g -O0 main.c -o prog

# Debug con ottimizzazioni (per profiling in release)
gcc -g -O2 main.c -o prog

# Split DWARF (debug info separate per linking più veloce)
gcc -g -gsplit-dwarf main.c -o prog  # produce anche main.dwo

# Setup raccomandato per sviluppo
gcc -Wall -Wextra -Wpedantic -Wshadow -Wconversion main.c

# Setup rigido GCC (CI/CD)
gcc -Wall -Wextra -Werror -Wpedantic -Wlogical-op -Wduplicated-cond main.c

# Setup rigido Clang (CI/CD)
clang -Weverything -Wno-padded -Wno-disabled-macro-expansion -Werror main.c

# Sopprimere un warning nel codice sorgente (GCC)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wunused-variable"
int x = 42;
#pragma GCC diagnostic pop

# Sopprimere un warning nel codice sorgente (Clang)
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wunused-variable"
int x = 42;
#pragma clang diagnostic pop

# Rileva: buffer overflow, use-after-free, stack overflow, memory leak
gcc -fsanitize=address -g -O1 main.c -o prog
./prog

# Con rilevamento leak (abilitato di default su Linux)
ASAN_OPTIONS=detect_leaks=1 ./prog

# Opzioni utili
ASAN_OPTIONS=halt_on_error=0:detect_stack_use_after_return=1 ./prog

# Rileva: signed overflow, null deref, shift errati, type punning
gcc -fsanitize=undefined -g main.c -o prog

# Sottogruppi specifici
gcc -fsanitize=signed-integer-overflow,null,shift main.c

# Combinare ASan + UBSan
gcc -fsanitize=address,undefined -g -O1 main.c -o prog

# Rileva: lettura di memoria non inizializzata
clang -fsanitize=memory -g -O1 -fno-omit-frame-pointer main.c -o prog

# Con tracking dell'origine del valore non inizializzato
clang -fsanitize=memory -fsanitize-memory-track-origins=2 -g main.c

# Rileva: data race, deadlock
gcc -fsanitize=thread -g -O1 main.c -lpthread -o prog

# Analisi statica integrata (GCC 10+)
gcc -fanalyzer main.c -o prog

# Combinare con warning aggressivi
gcc -fanalyzer -Wall -Wextra main.c

# Disabilitare un warning specifico dell'analyzer
gcc -fanalyzer -Wno-analyzer-double-free main.c

Rileva: use-after-free, double-free, null dereference, memory leak, buffer overflow, file descriptor leak, use-of-uninitialized-value. Vantaggio: integrato nel compilatore, nessun tool esterno necessario.

# Analisi statica su un singolo file
clang --analyze main.c

# Con output dettagliato
clang --analyze -Xanalyzer -analyzer-output=text main.c

# Abilitare checker specifici
clang --analyze -Xanalyzer -analyzer-checker=core,deadcode,security main.c

# Lista checker disponibili
clang --analyze -Xanalyzer -analyzer-checker-help

# Analizzare un intero progetto basato su make
scan-build make

# Con report HTML
scan-build -o ./report make

# Specificare il compilatore
scan-build --use-cc=clang --use-c++=clang++ make

# Analizzare un progetto CMake
scan-build cmake --build build/

# Clang: ottimizzazioni applicate
clang -O2 -Rpass=. main.c -o prog

# Clang: ottimizzazioni mancate
clang -O2 -Rpass-missed=. main.c

# Clang: solo vectorization
clang -O2 -Rpass=loop-vectorize -Rpass-missed=loop-vectorize main.c

# GCC: dump di tutte le ottimizzazioni applicate
gcc -O2 -fopt-info-all main.c -o prog

# GCC: solo vectorization
gcc -O2 -fopt-info-vec-missed main.c

# GCC: dump su file
gcc -O2 -fopt-info-all=optim.log main.c

# Compilazione con Full LTO
gcc -flto -O2 -c a.c
gcc -flto -O2 -c b.c
gcc -flto -O2 a.o b.o -o prog

# In un solo comando
gcc -flto -O2 a.c b.c -o prog

# GCC: LTO parallelizzato
gcc -flto=auto -O2 a.c b.c -o prog   # usa tutti i core
gcc -flto=4 -O2 a.c b.c -o prog      # usa 4 core

# ThinLTO: più veloce di Full LTO, parallelizzabile
clang -flto=thin -O2 a.c b.c -o prog

# Con cache per build incrementali
clang -flto=thin -O2 -Wl,-cache_path_lto,/tmp/lto-cache a.c b.c -o prog

# Fase 1: compilare con instrumentazione
gcc -fprofile-generate -O2 main.c -o prog.instr

# Fase 2: eseguire con input rappresentativo
./prog.instr < typical_input.txt
# genera file .gcda nella directory corrente

# Fase 3: ricompilare con il profilo
gcc -fprofile-use -O2 main.c -o prog.opt

# Con correzione automatica per profili imprecisi
gcc -fprofile-use -fprofile-correction -O2 main.c -o prog.opt

# Fase 1: compilare con instrumentazione
clang -fprofile-instr-generate -O2 main.c -o prog.instr

# Fase 2: eseguire con input rappresentativo
./prog.instr < typical_input.txt
# genera default.profraw

# Fase 2b: convertire il profilo (necessario per Clang)
llvm-profdata merge -output=default.profdata default.profraw

# Fase 3: ricompilare con il profilo
clang -fprofile-instr-use=default.profdata -O2 main.c -o prog.opt

# Alternativa: profiling tramite perf (no instrumentazione, solo Linux)
gcc -O2 -g main.c -o prog
perf record -b ./prog

# GCC: usare profilo AutoFDO
create_gcov --binary=prog --profile=perf.data --gcov=profile.afdo
gcc -fauto-profile=profile.afdo -O2 main.c -o prog.opt

# Clang: usare profilo sampling
llvm-profgen --binary=prog --output=perf.profdata --perfdata=perf.data
clang -fprofile-sample-use=perf.profdata -O2 main.c -o prog.opt

# Compilare con profiling
gcc -pg -O2 main.c -o prog

# Eseguire (genera gmon.out)
./prog

# Analizzare il profilo
gprof prog gmon.out                     # report completo
gprof -b prog gmon.out                  # report breve (senza spiegazioni)
gprof -p prog gmon.out                  # solo flat profile
gprof -q prog gmon.out                  # solo call graph

# Compilare con coverage
gcc --coverage -O0 main.c -o prog
# equivale a: gcc -fprofile-arcs -ftest-coverage main.c

# Eseguire (genera .gcda)
./prog

# Analizzare coverage
gcov main.c                             # genera main.c.gcov
gcov -b main.c                          # con info sui branch

# Report HTML con lcov
lcov --capture --directory . --output-file coverage.info
genhtml coverage.info --output-directory report/

# Compilare con coverage
clang -fprofile-instr-generate -fcoverage-mapping main.c -o prog

# Eseguire
./prog

# Convertire profilo e visualizzare
llvm-profdata merge default.profraw -o default.profdata
llvm-cov show prog -instr-profile=default.profdata

# Report riassuntivo
llvm-cov report prog -instr-profile=default.profdata

# Esportare in HTML
llvm-cov show prog -instr-profile=default.profdata -format=html -output-dir=report/

# Formato: <arch>-<vendor>-<os>-<abi>
x86_64-unknown-linux-gnu         # Linux x86_64 con glibc
x86_64-unknown-linux-musl        # Linux x86_64 con musl
aarch64-unknown-linux-gnu        # Linux ARM64
arm-none-eabi                    # Bare-metal ARM (embedded)
riscv64-unknown-linux-gnu        # Linux RISC-V 64-bit
wasm32-unknown-wasi              # WebAssembly (WASI)
x86_64-apple-darwin              # macOS x86_64
aarch64-apple-darwin             # macOS ARM (Apple Silicon)
x86_64-pc-windows-msvc           # Windows MSVC ABI

# Cross-compilare per ARM64 Linux
clang --target=aarch64-unknown-linux-gnu main.c -o prog

# Con sysroot (header e librerie del target)
clang --target=aarch64-unknown-linux-gnu --sysroot=/opt/sysroot/arm64 main.c

# Per bare-metal ARM (embedded)
clang --target=arm-none-eabi -ffreestanding -nostdlib startup.c -o firmware.elf

# Per WebAssembly
clang --target=wasm32-unknown-wasi --sysroot=/opt/wasi-sdk/share/wasi-sysroot main.c -o prog.wasm

# Mostrare il target corrente
clang -print-target-triple

# GCC richiede una toolchain per-target (installata separatamente)
# Esempio: su Debian/Ubuntu
sudo apt install gcc-aarch64-linux-gnu

# Cross-compilare per ARM64 Linux
aarch64-linux-gnu-gcc main.c -o prog

# Per bare-metal ARM
arm-none-eabi-gcc -ffreestanding -nostdlib startup.c -o firmware.elf

# Mostrare il target configurato
gcc -dumpmachine

# Lista CPU disponibili per un target
gcc -march=native -Q --help=target     # GCC
llc -march=arm -mcpu=help               # LLVM/Clang

# Compilare per una CPU specifica
gcc -march=armv7-a -mfloat-abi=hard -mfpu=neon main.c

# typeof (pre-C23; in C23 è typeof standard)
typeof(x) y = x;

# Statement expression (blocco come espressione)
#define MAX(a,b) ({ typeof(a) _a=(a); typeof(b) _b=(b); _a>_b?_a:_b; })

# Designated initializer range (GCC/Clang extension)
int arr[100] = { [0 ... 9] = 1, [10 ... 99] = 2 };

# Case range in switch
case 0 ... 9: /* gestisci cifre */

# Labels as values (computed goto)
void *labels[] = { &&label_a, &&label_b };
goto *labels[idx];

# Formattare un file (output su stdout)
clang-format main.c

# Formattare in-place
clang-format -i main.c

# Con stile predefinito
clang-format -style=google main.c       # google, llvm, chromium, mozilla, webkit

# Generare file di configurazione
clang-format -style=llvm -dump-config > .clang-format

# Formattare tutti i file C/C++ ricorsivamente
find . -name '*.c' -o -name '*.h' | xargs clang-format -i

# Analisi con check di default
clang-tidy main.c --

# Con check specifici
clang-tidy -checks='bugprone-*,modernize-*,performance-*' main.cpp --

# Applicare fix automaticamente
clang-tidy -checks='modernize-*' -fix main.cpp --

# Con compilation database (da CMake)
cmake -DCMAKE_EXPORT_COMPILE_COMMANDS=ON .
clang-tidy -p build/ main.cpp

# Disassemblare un binario
objdump -d prog                        # GNU
llvm-objdump -d prog                   # LLVM

# Con codice sorgente interleaved
objdump -d -S prog

# Elencare simboli
nm prog                                 # tutti i simboli
nm -u prog                              # solo undefined (dipendenze esterne)

# Strippare il binario per la release
strip prog

# GCC: build di produzione
gcc -O2 -DNDEBUG -flto=auto \
  -fstack-protector-strong -D_FORTIFY_SOURCE=2 \
  -fPIE -pie -Wl,-z,relro,-z,now \
  -fstack-clash-protection \
  -Wall -Wextra -Werror \
  main.c -o prog

# Clang: build di produzione
clang -O2 -DNDEBUG -flto=thin \
  -fstack-protector-strong -D_FORTIFY_SOURCE=2 \
  -fPIE -pie -Wl,-z,relro,-z,now \
  -fsanitize=cfi -fvisibility=hidden \
  -Wall -Wextra -Werror \
  main.c -o prog

# Mostrare le directory di ricerca include
gcc -v -E -x c /dev/null

# Mostrare tutte le flag abilitate per un livello di ottimizzazione
gcc -O2 -Q --help=optimizers             # GCC
clang -O2 -mllvm -print-all-options      # Clang

# CPU supportate
gcc -march=native -Q --help=target
clang -print-supported-cpus

# AST dump (Clang)
clang -Xclang -ast-dump -fsyntax-only main.c

# Tempo di compilazione per fase
gcc -ftime-report main.c -o prog
clang -ftime-report main.c -o prog

# GCC: dump delle rappresentazioni interne
gcc -fdump-tree-all -O2 main.c         # dump di tutti i pass GIMPLE

# CMake genera compile_commands.json
cmake -DCMAKE_EXPORT_COMPILE_COMMANDS=ON -B build

# Per progetti basati su make: usare Bear
bear -- make

# Usato automaticamente da clang-tidy, clangd (LSP), e altri tool