gcc

This tutorial demonstrates how to add JIT-compilation to a simple stack-based interpreter using libgccjit, with code examples and explanations.

A LWN comment discusses the relatively recent implementation of tail-call optimization in C compilers, citing historical limitations and noting that modern GCC and Clang now support it, with potential benefits for interpreter implementations.

A blog post examines an ambiguity in the C89 standard about implicit function declarations, where GCC and Clang disagree on interpretation, leading to different compile results for certain code.

The gccrs project, creating a Rust frontend for GCC, has made progress toward compiling the Linux kernel, resolving issues in attribute handling, name resolution, and resource management, and reorganizing development milestones.

The GCC steering committee has accepted an AI contributions policy that will decline legally significant contributions containing LLM-generated content, with exceptions for test cases, while allowing LLM use for research and analysis.

The article explores the limitations of GCC's large code model (mcmodel=large), particularly its inability to handle Thread Local Storage (TLS) with 32-bit relocations, making it unusable for truly large binaries despite its stated purpose.

This blog post explores parsing ambiguities in C23 involving `auto` as a type inference specifier or storage-class specifier, showing how GCC and Clang disagree on parsing declarations like `auto x = 67;` when `x` is a typedef, and how attributes complicate the situation.

A blog post describes the process of building GCC 1.27, a 1988 compiler, on a modern Ubuntu system, detailing necessary patches and steps.

A practical guide to setting up an AmigaOS development environment on Linux, covering toolchain installation, emulation, and remote debugging.

GCC 16 ensures nested functions that don't capture variables require no trampolines, improving security. GCC 17 introduces built-in functions to avoid trampolines even for captured nested functions, using wide pointers and static chain registers.

Explains the use of GCC's computed goto extension to improve the performance of bytecode VM dispatch tables compared to traditional switch statements, with a simple example.

Raymond Chen explores gcc libstdc++'s rotation algorithm for random-access iterators, revealing it is fundamentally the same as the forward-iterator rotation algorithm, just viewed from a different perspective. The post is part of a series comparing rotation implementations across compilers.

José Marchesi and the GCC-BPF team provided an update on BPF support in GCC 16, highlighting progress toward feature parity with LLVM and increasing pass rate of the kernel's BPF self-tests.

This article discusses the practical challenges of writing portable C code due to reliance on non-standard compiler extensions and glibc's conditional headers, illustrating with examples from building a C compiler.

This blog post explains how to build a host-tuned GCC compiler using profile-guided optimization, LTO, and -O3 to achieve faster compilation times, with detailed instructions and benchmarks.

GCC 16 introduces improved hierarchical error messages for C++ templates and updated SARIF machine-readable diagnostic output, enhancing developer experience.

Matt Godbolt explores compiler optimizations that convert an O(n) summation loop into an O(1) closed-form solution, highlighting how Clang and GCC employ sophisticated techniques like loop unrolling and mathematical simplification to dramatically improve code performance.