GCC

# Install (Ubuntu/Debian)
sudo apt install gcc-14 g++-14

# Compile
g++-14 -std=c++23 -O2 -Wall -Wextra -o myapp main.cpp

# With sanitizers (dev builds)
g++-14 -std=c++20 -O1 -fsanitize=address,undefined -fno-omit-frame-pointer -o myapp main.cpp

# Recommended baseline
-Wall -Wextra -Wpedantic

# Stronger — catches more real bugs
-Wall -Wextra -Wpedantic -Wshadow -Wconversion -Wsign-conversion \
  -Wnull-dereference -Wdouble-promotion -Wformat=2

# For header-only libs (treat warnings as errors)
-Werror

-O0    # No optimization — fast compilation, best for debugging
-O1    # Minimal optimization — good for sanitizer builds
-O2    # Standard release — best balance (use this)
-O3    # Aggressive — more vectorization, sometimes slower due to code size
-Os    # Optimize for size (embedded)
-Og    # Debug-friendly optimization (GCC only)

-g        # Include debug info (DWARF)
-g3       # Include macro definitions too
-ggdb     # GDB-specific extensions
-fno-omit-frame-pointer  # Keep frame pointer for profilers/sanitizers

# Enable LTO (major win for release builds)
g++ -O2 -flto -fuse-linker-plugin -o myapp main.cpp lib.cpp

# Thin LTO (parallel, faster than full LTO)
g++ -O2 -flto=auto -o myapp main.cpp lib.cpp

# Cross-compile for ARM (embedded)
arm-none-eabi-g++ -std=c++20 -mcpu=cortex-m4 -mfpu=fpv4-sp-d16 -mfloat-abi=hard \
  -Os -fno-exceptions -fno-rtti -o firmware.elf main.cpp

# RISC-V
riscv64-unknown-elf-g++ -march=rv64imafd -mabi=lp64d -o app main.cpp

# WebAssembly (via Emscripten, which uses LLVM internally but has GCC-compatible flags)
em++ -std=c++20 -O2 -o app.wasm main.cpp

# AddressSanitizer (heap/stack buffer overflows, use-after-free)
-fsanitize=address

# UndefinedBehaviorSanitizer (signed overflow, null deref, etc.)
-fsanitize=undefined

# ThreadSanitizer (data races)
-fsanitize=thread

# Combine ASan + UBSan (most useful combination)
-fsanitize=address,undefined -fno-omit-frame-pointer

# Show include paths resolved
-H

# Show where a macro is defined
-fdump-macro-expansion

# Show compilation time breakdown
-ftime-report

# Preprocessor output only
-E

# Assembly output (readable)
-S -fverbose-asm

cmake_minimum_required(VERSION 3.20)
project(myapp CXX)

set(CMAKE_CXX_STANDARD 20)
set(CMAKE_CXX_STANDARD_REQUIRED ON)

add_executable(myapp main.cpp)

# Apply warning flags
target_compile_options(myapp PRIVATE
  $<$<CXX_COMPILER_ID:GNU>:-Wall -Wextra -Wpedantic -Wshadow>
)

# Enable LTO for Release builds
set_target_properties(myapp PROPERTIES INTERPROCEDURAL_OPTIMIZATION_RELEASE ON)

# C++11 through C++23 — stable spelling
g++ -std=c++11 ...
g++ -std=c++14 ...
g++ -std=c++17 ...
g++ -std=c++20 ...
g++ -std=c++23 ...

# C++26 draft (GCC 14+) — uses transitional flag
g++ -std=c++2c ...    # accepted alias while standard is still being finalized
# GCC 15 also accepts -std=c++26

# GNU extensions (default when no -std is given — avoid for portable code)
g++ -std=gnu++23 ...  # C++23 + GNU extensions

g++ -v                        # shows GCC version
g++ -std=c++23 -x c++ - < /dev/null 2>&1 | head -5   # quick standard flag test

-O0    # No optimization. Fastest compilation. Every C++ statement maps 1:1 to
       # instructions. Best for step-through debugging.

-O1    # ~50 fast passes: dead code elimination, basic inlining, register
       # allocation. Good for sanitizer builds (ASan/UBSan work best here).

-O2    # The production default. Adds vectorization, loop unrolling, CSE,
       # instruction scheduling. The right choice for almost all release builds.

-O3    # Adds more aggressive loop transformations, more inlining, function
       # cloning. Can be slower than -O2 when code size growth blows I-cache.
       # Always benchmark; do not assume faster.

-Os    # Like -O2 but disables transformations that increase code size.
       # Best for embedded targets with tight flash constraints.

-Oz    # Clang-only; GCC uses -Os for size. Included here for reference.

-Og    # Debug-friendly optimization (GCC-specific). Superset of -O1 with
       # extra passes that don't hinder debugging. Better than -O0 for
       # catching optimizer-exposed bugs while keeping debug info usable.

# Tune for the machine compiling the binary — never ship these binaries to other hosts
-march=native        # Enable all ISA extensions the build host supports (AVX2, etc.)
-mtune=native        # Schedule for build host's microarchitecture, keep ABI portable

# Target a specific micro-arch for distribution
-march=x86-64-v3     # AVX2 baseline — safe for most 2015+ x86 machines
-march=armv8-a       # Generic ARMv8 (Cortex-A53 and up)
-mcpu=cortex-a72     # ARM: sets both -march and -mtune equivalent

# Separate march from mtune
-march=x86-64 -mtune=znver4   # Compile for any x86-64, schedule for AMD Zen 4

# CAUTION: -ffast-math breaks IEEE 754 compliance
-ffast-math          # Enables: -fno-math-errno, -funsafe-math-optimizations,
                     # -ffinite-math-only, -fno-rounding-math, -fno-signaling-nans,
                     # -fcx-limited-range. NaN/Inf checks silently wrong.
                     # Fine for game physics; dangerous for finance or scientific code.

-fno-math-errno      # Safe subset: skip errno after math calls (most code never
                     # checks it). Enables vectorization of sqrt/sin/cos.

-fassociative-math   # Allows reordering floating-point ops — breaks numerical
                     # algorithms that depend on ordering (Kahan summation, etc.)

-fomit-frame-pointer   # GCC enables this at -O1+. Frees one register on x86.
                        # Breaks profilers (perf, gprof) and some stack unwinders.

-fno-omit-frame-pointer # Restore frame pointer. Required when using ASan or
                         # perf with frame-pointer-based unwinding.
                         # Tiny performance cost (~1%) worth paying in dev builds.

# Full LTO — single-threaded link optimization (slow for large projects)
g++ -O2 -flto -o myapp main.cpp lib.cpp util.cpp

# Parallel LTO — uses all available cores during link
g++ -O2 -flto=auto -o myapp main.cpp lib.cpp util.cpp

# Explicit thread count
g++ -O2 -flto=8 -o myapp main.cpp lib.cpp util.cpp

# LTO requires the same flags at compile and link time
g++ -O2 -flto -c -o main.o main.cpp
g++ -O2 -flto -c -o lib.o lib.cpp
g++ -O2 -flto -o myapp main.o lib.o    # linker triggers LTO pass here

# Gold linker (GNU gold) with LTO plugin — faster linking than ld.bfd for large projects
g++ -O2 -flto -fuse-linker-plugin -fuse-ld=gold -o myapp main.cpp lib.cpp

# Or use lld (LLVM linker) which also supports GCC LTO bitcode
g++ -O2 -flto -fuse-ld=lld -o myapp main.cpp lib.cpp

# Option 1: Per-target (preferred — fine-grained control)
set_property(TARGET myapp PROPERTY INTERPROCEDURAL_OPTIMIZATION TRUE)

# Option 2: Global (enables LTO on all targets)
set(CMAKE_INTERPROCEDURAL_OPTIMIZATION TRUE)

# Option 3: Release-only LTO (avoids slow debug link times)
set_target_properties(myapp PROPERTIES
  INTERPROCEDURAL_OPTIMIZATION_RELEASE TRUE
  INTERPROCEDURAL_OPTIMIZATION_RELWITHDEBINFO TRUE
)

# Step 1: Instrument binary — compiles with profiling hooks
g++ -O2 -fprofile-generate -o myapp_instrumented main.cpp lib.cpp

# Step 2: Run with representative workloads — generates .gcda profile files
./myapp_instrumented workload1.dat
./myapp_instrumented workload2.dat
./myapp_instrumented --benchmark

# Step 3: Recompile using collected profile data
g++ -O2 -fprofile-use=. -fprofile-correction -o myapp main.cpp lib.cpp
# -fprofile-use=<dir> points to the directory containing .gcda files
# -fprofile-correction handles mismatched counts from parallel runs

g++ -O2 -fprofile-generate=/tmp/pgo-data -o myapp_inst main.cpp
./myapp_inst workload.dat
g++ -O2 -fprofile-use=/tmp/pgo-data -o myapp main.cpp

# Phase 1: instrument build
add_compile_options(-O2 -fprofile-generate)
add_link_options(-fprofile-generate)

# Phase 2: after running workloads, switch to:
add_compile_options(-O2 -fprofile-use=${CMAKE_SOURCE_DIR}/pgo-data -fprofile-correction)

# Tier 1 — always on, no false positives
-Wall              # ~30 individual warnings: uninitialized vars, unused results,
                   # implicit int, missing returns, etc.
-Wextra            # Additional: unused parameters, missing field initializers,
                   # sign comparison, empty body in if/else, etc.
-Wpedantic         # Strict ISO C++ conformance warnings (non-standard extensions)

# Tier 2 — highly recommended, rare false positives
-Wshadow           # Warns when a local variable shadows an outer-scope name.
                   # Catches subtle bugs: void f(int x) { int x = 0; ... }
-Wconversion       # Implicit conversions that may change value (int→char, etc.)
-Wsign-conversion  # Signed/unsigned implicit conversions specifically
-Wold-style-cast   # C-style casts (int*)ptr. Force static_cast/reinterpret_cast.
-Wnull-dereference # GCC flow-analysis: detects provably null pointer dereferences
-Wformat=2         # Stricter printf/scanf format string checking (includes =1 + more)

# Tier 3 — GCC-specific, high value
-Wduplicated-cond  # if (a) ... else if (a) ... — always-false else branch
-Wduplicated-branches  # if/else where both branches are identical (copy-paste bug)
-Wlogical-op       # Suspicious use of && or || where bitwise & or | was likely meant
-Wuseless-cast     # Casting a value to its own type: static_cast<int>(int_var)
-Wmisleading-indentation  # Indentation doesn't match block structure (duff's device)
-Wno-unused-parameter  # Suppress -Wextra's unused-param when you need stub methods

# Development / CI baseline
-Wall -Wextra -Wpedantic -Wshadow -Wconversion -Wsign-conversion \
  -Wnull-dereference -Wformat=2 -Wduplicated-cond -Wlogical-op

# Strict / library development (all of above + errors)
-Wall -Wextra -Wpedantic -Wshadow -Wconversion -Wsign-conversion \
  -Wnull-dereference -Wformat=2 -Wduplicated-cond -Wlogical-op \
  -Wold-style-cast -Wuseless-cast -Werror

# Embedded / safety-critical
-Wall -Wextra -Wpedantic -Wshadow -Wconversion -Wsign-conversion \
  -Wformat=2 -Wduplicated-cond -Wlogical-op -Werror \
  -Wstack-usage=512 -Wlarger-than=1024

// Force inlining regardless of -O level or compiler heuristics
__attribute__((always_inline)) inline int fast_abs(int x) {
    return x < 0 ? -x : x;
}

// Prevent inlining — useful for error-path functions to keep hot code compact
__attribute__((noinline)) void handle_error(const char* msg) {
    fprintf(stderr, "Error: %s\n", msg);
    std::terminate();
}

// Pack struct to minimum size — no padding inserted
struct __attribute__((packed)) WireHeader {
    uint8_t  version;
    uint16_t length;   // sits at offset 1 (unaligned on most arches — beware!)
    uint32_t checksum; // sits at offset 3
};
// sizeof(WireHeader) == 7, not 8

// Explicit alignment
struct __attribute__((aligned(64))) CacheLine {
    double data[8];    // occupies exactly one 64-byte cache line
};

// Tell GCC which branch is the common case
// __builtin_expect(expr, expected_value)
if (__builtin_expect(ptr == nullptr, 0)) {   // 0 = unlikely
    handle_null();
}

// C++20 standard equivalent (prefer this in new code)
[[likely]]   if (x > 0) { ... }
[[unlikely]] if (x == nullptr) { ... }

// Tell the optimizer a code path is never taken
// Allows better codegen — eliminates dead branches
switch (dir) {
    case North: return move_north();
    case South: return move_south();
    case East:  return move_east();
    case West:  return move_west();
    default:    __builtin_unreachable();  // no default case in your enum? say so.
}

// C++23 standard equivalent (prefer over __builtin_unreachable in new code)
std::unreachable();  // <utility>

// Mark function as pure (no side effects, result depends only on args + globals)
__attribute__((pure))  int compute(int x);

// Mark function as const (stricter: result depends only on args, reads no globals)
__attribute__((const)) int square(int x);

// Warn at call sites if return value is ignored (pre-C++17 [[nodiscard]])
__attribute__((warn_unused_result)) int fread_checked(...);

// Function is cold (rarely called) — optimize for size, move out of hot section
__attribute__((cold)) void dump_state();

// Visibility control for shared libraries
__attribute__((visibility("default"))) void public_api();
__attribute__((visibility("hidden")))  void internal_helper();

# ARM 32-bit Linux (Raspberry Pi 2/3 in 32-bit mode, Cortex-A)
sudo apt install g++-arm-linux-gnueabihf

# ARM 64-bit Linux (Raspberry Pi 4/5, most modern SBCs)
sudo apt install g++-aarch64-linux-gnu

# RISC-V 64-bit Linux
sudo apt install g++-riscv64-linux-gnu

# ARM bare-metal (no OS — microcontrollers, Cortex-M)
sudo apt install gcc-arm-none-eabi

# MIPS Linux (routers, legacy embedded)
sudo apt install g++-mips-linux-gnu

# ARM 32-bit Linux hard-float ABI
arm-linux-gnueabihf-g++ -std=c++20 -O2 \
  -march=armv7-a -mfpu=neon-vfpv4 -mfloat-abi=hard \
  -o app_arm32 main.cpp

# ARM 64-bit Linux
aarch64-linux-gnu-g++ -std=c++23 -O2 -o app_arm64 main.cpp

# RISC-V 64-bit Linux
riscv64-linux-gnu-g++ -std=c++20 -O2 \
  -march=rv64imafdc -mabi=lp64d \
  -o app_riscv64 main.cpp

# Verify the output architecture
file app_arm64   # "ELF 64-bit LSB executable, ARM aarch64"

# cmake/toolchain-aarch64.cmake
set(CMAKE_SYSTEM_NAME Linux)
set(CMAKE_SYSTEM_PROCESSOR aarch64)

set(CROSS_PREFIX aarch64-linux-gnu-)
set(CMAKE_C_COMPILER   ${CROSS_PREFIX}gcc)
set(CMAKE_CXX_COMPILER ${CROSS_PREFIX}g++)
set(CMAKE_STRIP        ${CROSS_PREFIX}strip)

# Sysroot — optional but needed for linking against target libraries
set(CMAKE_SYSROOT /opt/sysroots/aarch64-linux-gnu)
set(CMAKE_FIND_ROOT_PATH ${CMAKE_SYSROOT})

# Only search in the sysroot for headers/libs, not the host machine
set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER)
set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY)
set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY)

cmake -B build-arm64 \
  -DCMAKE_TOOLCHAIN_FILE=cmake/toolchain-aarch64.cmake \
  -DCMAKE_BUILD_TYPE=Release
cmake --build build-arm64

# Install user-mode QEMU for the target arch
sudo apt install qemu-user qemu-user-static

# Run ARM64 binary transparently on x86 host
qemu-aarch64-static -L /usr/aarch64-linux-gnu ./app_arm64

# Or register binfmt_misc handlers so it's fully transparent
sudo apt install binfmt-support
./app_arm64    # runs via QEMU automatically

# Method 1: environment variable (set before cmake configure)
# $ CXX=g++-14 cmake -B build

# Method 2: CMake cache variable
cmake -B build -DCMAKE_CXX_COMPILER=g++-14

# Method 3: toolchain file (portable, checked into repo)
# cmake/toolchain-gcc14.cmake:
set(CMAKE_CXX_COMPILER g++-14)

cmake_minimum_required(VERSION 3.25)
project(myapp LANGUAGES CXX)

# Require C++20 — no silent fallback to older standard
set(CMAKE_CXX_STANDARD 20)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
set(CMAKE_CXX_EXTENSIONS OFF)   # -std=c++20 not -std=gnu++20

add_executable(myapp main.cpp src/engine.cpp)

# GCC-specific warnings — won't apply to Clang/MSVC builds
target_compile_options(myapp PRIVATE
  $<$<CXX_COMPILER_ID:GNU>:
    -Wall -Wextra -Wpedantic
    -Wshadow -Wconversion -Wsign-conversion
    -Wnull-dereference -Wformat=2
    -Wduplicated-cond -Wlogical-op
  >
)

# LTO — CMake 3.9+ checks compiler support automatically
set_property(TARGET myapp PROPERTY INTERPROCEDURAL_OPTIMIZATION TRUE)

# Or enable only for Release/RelWithDebInfo
set_target_properties(myapp PROPERTIES
  INTERPROCEDURAL_OPTIMIZATION_RELEASE         TRUE
  INTERPROCEDURAL_OPTIMIZATION_RELWITHDEBINFO  TRUE
)

# PGO — Phase 1 (instrument)
target_compile_options(myapp PRIVATE
  $<$<CXX_COMPILER_ID:GNU>:-fprofile-generate=${CMAKE_BINARY_DIR}/pgo>
)
target_link_options(myapp PRIVATE
  $<$<CXX_COMPILER_ID:GNU>:-fprofile-generate=${CMAKE_BINARY_DIR}/pgo>
)

# PGO — Phase 2 (use profile, separate CMake configure)
target_compile_options(myapp PRIVATE
  $<$<CXX_COMPILER_ID:GNU>:
    -fprofile-use=${CMAKE_BINARY_DIR}/pgo
    -fprofile-correction
  >
)

# Guard features available only in GCC 12+
if (CMAKE_CXX_COMPILER_ID STREQUAL "GNU" AND
    CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL "12.0")
  target_compile_options(myapp PRIVATE -Wduplicated-branches)
endif()

# Print detected compiler info
message(STATUS "Compiler: ${CMAKE_CXX_COMPILER_ID} ${CMAKE_CXX_COMPILER_VERSION}")