# LLVM Project

Recent content on The LLVM Project Blog

This is one page of public article previews, not the complete archive. Follow Next page to continue. Summaries are not the original full articles.

## GSoC 2026 - Adding Fortran Support to LLDB

DevFeed: [GSoC 2026 - Adding Fortran Support to LLDB](<https://devfeed.tech/articles/gsoc-2026-adding-fortran-support-to-lldb-134731.md>)

Original publisher: [Read original article](<https://blog.llvm.org/posts/2026-09-07-gsoc-add-fortran-support-to-lldb/>)

Author: Iason Karaprodromidis

Published: 2026-11-16T00:00:00Z

Content type: article

Language: en

Sources: [LLVM Project](<https://devfeed.tech/sources/the-llvm-project-blog.md>)

Topics: [Fortran](<https://devfeed.tech/topics/fortran.md>), [Tool](<https://devfeed.tech/topics/tool.md>), [Test automation](<https://devfeed.tech/topics/test-automation.md>)

Tags: [2026](<https://devfeed.tech/tags/2026.md>), [architecture](<https://devfeed.tech/tags/architecture.md>), [arrays](<https://devfeed.tech/tags/arrays.md>), [debugging](<https://devfeed.tech/tags/debugging.md>), [flang](<https://devfeed.tech/tags/flang.md>), [fortran](<https://devfeed.tech/tags/fortran.md>), [foundations](<https://devfeed.tech/tags/foundations.md>), [functions](<https://devfeed.tech/tags/functions.md>), [gsoc](<https://devfeed.tech/tags/gsoc.md>), [implementation](<https://devfeed.tech/tags/implementation.md>), [integration](<https://devfeed.tech/tags/integration.md>), [language](<https://devfeed.tech/tags/language.md>), [lldb](<https://devfeed.tech/tags/lldb.md>), [llvm](<https://devfeed.tech/tags/llvm.md>), [plugin](<https://devfeed.tech/tags/plugin.md>), [pointers](<https://devfeed.tech/tags/pointers.md>), [providers](<https://devfeed.tech/tags/providers.md>), [support](<https://devfeed.tech/tags/support.md>), [synthetic](<https://devfeed.tech/tags/synthetic.md>)

### AI overview

The project adds native Fortran support to LLDB for primitive types, functions and subroutines, pointers, and arrays, building a foundation for a future Flang-backed debugger. A DWARF parser extracts compiler metadata, a Fortran TypeSystem represents it, and a language plugin provides formatting and synthetic children. Dynamic array bounds and strides are resolved at inspection time from runtime descriptors through synthetic children, avoiding changes to LLDB's core interfaces. Current limits include no expression evaluator yet, unfinished upstreaming, and deferred strings and derived types. Array inspection uses chained C-style brackets; assumed-size arrays allow indexing without known upper bounds but cannot display trailing sub-arrays.

### Source excerpt

GSoC 2026 - Adding Fortran Support to LLDB (LLVM) While Flang has matured, the developer tooling around it has lagged behind. In particular it lacks a dedicated debugger. LLDB lacks native Fortran support, it is only able to resolve basic breakpoints via raw line tables. This project adds support for Fortran in LLDB and lays the foundations on which a fully-featured Flang-backed debugger can be built. Specifically, this work introduces native support for: Primitive types (INTEGER, REAL, LOGICAL, COMPLEX) Arrays Pointers Functions Current Status & Running the Code Because the upstreaming process for a project of this scale is ongoing, not all features have been merged into the LLVM main branch yet. However a working implementation is available for anyone to test. You can view the full set of changes, clone the code, and compile it yourself from my personal branch. To keep up to date with the ongoing integration of this project, you can follow the tracking issue. High-Level Architecture Adding a new language to LLDB requires teaching it how to extract, represent, and display the values from compiled binaries. This relies on three core components: DWARFASTParser: Parses compiler-generated DWARF debug information and extracts raw type metadata (e.g., symbol names, byte sizes, and layouts). TypeSystem: Represents the internal type model of the language within LLDB. It takes the metadata parsed from DWARF and constructs native LLDB type representations. Language Plugin: Registers Fortran with LLDB and supplies language-specific pretty-printers, value formatters, and synthetic children providers. For more details on how to add a new language to LLDB, see the official documentation. RFC process When proposing any significant change to LLVM, it first needs to go through the RFC process. In short, a proposal is written providing an overview of the change, the motivation behind it, the overall architecture of what will be changed, and open questions. It then receives feedback,

## GSoC 2026 - Teach the Clang Static Analyzer to understand lifetime annotations

DevFeed: [GSoC 2026 - Teach the Clang Static Analyzer to understand lifetime annotations](<https://devfeed.tech/articles/gsoc-2026-teach-the-clang-static-analyzer-to-understand-lifetime-annotations-122900.md>)

Original publisher: [Read original article](<https://blog.llvm.org/posts/2026-08-24-gsoc-lifetime-annotations-csa/>)

Author: Benedek Kaibás

Published: 2026-11-08T00:00:00Z

Content type: article

Language: en

Sources: [LLVM Project](<https://devfeed.tech/sources/the-llvm-project-blog.md>)

Topics: [Static code analysis](<https://devfeed.tech/topics/static-code-analysis.md>), [clang](<https://devfeed.tech/topics/clang.md>), [Memory Safety](<https://devfeed.tech/topics/memory-safety.md>)

Tags: [2026](<https://devfeed.tech/tags/2026.md>), [annotations](<https://devfeed.tech/tags/annotations.md>), [clang](<https://devfeed.tech/tags/clang.md>), [google-summer-of-code](<https://devfeed.tech/tags/google-summer-of-code.md>), [gsoc](<https://devfeed.tech/tags/gsoc.md>), [lifetime](<https://devfeed.tech/tags/lifetime.md>), [static-analyzer](<https://devfeed.tech/tags/static-analyzer.md>)

### AI overview

The Clang Static Analyzer adds lifetime checking for cases `-Wlifetime-safety` can miss when a value's origin is lost at an opaque call. `LifetimeModeling` records annotated borrows and expired stack regions; `UseAfterLifetimeEnd` reports returns borrowing from a local, while `DanglingPtrDeref` reports dereferences or handoffs of pointers to expired objects. The analyzer can follow available callees and explore paths separately, and reports include the value's origin and execution path. Passing a dangling pointer is treated as a bug even if the callee does not dereference it; this can produce arguable false positives. Changes also recognize pointers into fields, array elements and base subobjects, and suppress repeated reports for the same variable. The source says both reporting checkers are in Clang and have been run over LLVM's monorepo. Future work includes modeling class values such as `std::string_view` and `std::span`, heap sources through `MallocChecker`, and `lifetime_capture_by` annotations.

### Source excerpt

Google Summer of Code 2026 @ LLVM Compiler Infrastructure Commits on GitHub | Pullrequests Motivation Clang can warn about lifetime bugs. Behind -Wlifetime-safety [1] it reads the lifetime annotations a function carries and reports a warning when a pointer or a reference that outlives the object it refers to escapes the function,or when the dead object is accessed through it. The analysis runs on every translation unit of every build and examines one function at a time, so an unannotated call is treated optimistically as having no lifetime effects:the origin of the value is lost at the call and bugs that depend on it go unreported. This project extends the Clang Static Analyzer (later referred to as CSA) to cover those cases. It reads the same annotations and follows the value through the callsthe compiler cannot enter, and the three checkers that came out of it are in Clang today, reporting bugs the compiler does not. Patches These are the patches that closed the gap, taking the analyzer from missing this class of bugs to catching it. #205521: implemented the UseAfterLifetimeEnd checker, which reports a value returned from a function while it still borrows from a local of that function. #205951: implemented the LifetimeModeling checker and moved every state operation out of UseAfterLifetimeEnd into it. #207052: implemented a BugReporterVisitor for UseAfterLifetimeEnd that adds the note showing where the value's lifetime was bound to its source. #209278: implemented DanglingPtrDeref, which reports a use of a pointer whose pointee has gone out of scope. #209862: NFC, corrected the DanglingPtrDeref checker's filename. #210801: suppressed the report when a lifetimebound method is called during the destruction of an object. #211045: added checkPostCall to DanglingPtrDeref so a dangling pointer passed as a call argument is reported. #211552: matched dangling subobjects by their base region, so a pointer into a field, an array element or a base class subobject of a dead o

## GSoC 2026: Enable float80/float128 on Unsupported Targets for LLVM libc

DevFeed: [GSoC 2026: Enable float80/float128 on Unsupported Targets for LLVM libc](<https://devfeed.tech/articles/gsoc-2026-enable-float80-float128-on-unsupported-targets-for-llvm-libc-122899.md>)

Original publisher: [Read original article](<https://blog.llvm.org/posts/2026-08-22-gsoc-float80-and-float128-in-llvm-libc/>)

Author: Sukumar Sawant

Published: 2026-11-02T00:00:00Z

Content type: news

Language: en

Sources: [LLVM Project](<https://devfeed.tech/sources/the-llvm-project-blog.md>)

Topics: [floating-point](<https://devfeed.tech/topics/floating-point.md>), [LLVM](<https://devfeed.tech/topics/llvm.md>), [clang](<https://devfeed.tech/topics/clang.md>)

Tags: [2026](<https://devfeed.tech/tags/2026.md>), [64-bit](<https://devfeed.tech/tags/64-bit.md>), [clang](<https://devfeed.tech/tags/clang.md>), [compiler](<https://devfeed.tech/tags/compiler.md>), [computer-science](<https://devfeed.tech/tags/computer-science.md>), [emulation](<https://devfeed.tech/tags/emulation.md>), [floating-point](<https://devfeed.tech/tags/floating-point.md>), [google](<https://devfeed.tech/tags/google.md>), [google-summer-of-code](<https://devfeed.tech/tags/google-summer-of-code.md>), [gsoc](<https://devfeed.tech/tags/gsoc.md>), [ieee](<https://devfeed.tech/tags/ieee.md>), [india](<https://devfeed.tech/tags/india.md>), [libc](<https://devfeed.tech/tags/libc.md>), [llvm](<https://devfeed.tech/tags/llvm.md>), [math](<https://devfeed.tech/tags/math.md>), [msvc](<https://devfeed.tech/tags/msvc.md>), [mumbai](<https://devfeed.tech/tags/mumbai.md>), [software](<https://devfeed.tech/tags/software.md>), [windows](<https://devfeed.tech/tags/windows.md>), [x86](<https://devfeed.tech/tags/x86.md>)

### AI overview

LLVM libc added software-emulated `Float128` and `Float80` so high-precision math code can build and be tested on targets lacking the corresponding native formats. The work added emulation types, operators and conversions, integrated them into floating-point support, and migrated `float128` math functions incrementally. A Windows build failure traced to `BigInt`'s zero-initialized member making it non-trivially constructible; moving initialization into constructors made `bit_cast` accept it. Testing also exposed ABI differences between native and emulated types, so migrated functions use emulation internally while retaining native `float128` parameters and returns when available. The article reports support for building and testing the types without native support and enabling `float128` functions on Windows with MSVC, macOS and GPU targets. Remaining work includes migrating more functions, adding explicit `float80` entrypoints and comparing performance.

### Source excerpt

Introduction Hello LLVM Community! I am Sukumar Sawant, Computer Science student at Mumbai University (VIT Mumbai), India. I had the pleasure of working on the project on introducing float80 and float128 (emulated) in LLVM libc as part of Google Summer of Code 2026 along with my mentors Tue Ly, Nicolas Celik and Krishna Pandey. "Why"? float80 and float128 are the two extended-precision floating-point formats LLVM libc supports. float80 is the 80-bit x87 extended precision format, with 1 sign bit, 15 exponent bits, and a 64-bit significand carrying an explicit integer bit. float128 is the IEEE 754 binary128 ("quad precision") format, with 1 sign bit, 15 exponent bits, and 112 stored mantissa bits. Both formats are already natively supported on several platforms, but not on all of them. For example: MSVC on Windows treats long double as a 64-bit double and has no native __float128 type. AArch64 targets typically use a 128-bit long double, but lack the 80-bit extended precision format entirely. Clang on certain non-x86 targets may not enable __float128 by default. This matters because LLVM libc needs to build and test its high-precision math routines consistently across every target it supports, not just the ones where these types happen to exist natively. Where the compiler provides no native type, the templated implementations cannot be compiled at all. The goal of this project was to lift that restriction by emulating both formats in software, so that the same templated implementations build and run everywhere, producing identical results whether the underlying type is native or emulated. The exact goals of this project were to: Add software emulation classes for the float80 and float128 formats. Provide the operator overloads and conversions needed for these classes to be used in place of the native types. Integrate the emulated types into the existing floating-point support infrastructure. Modify the existing float128 math functions to work correctly with the emul

## Static Memory Planner for MLIR: A GSoC 2026 Journey

DevFeed: [Static Memory Planner for MLIR: A GSoC 2026 Journey](<https://devfeed.tech/articles/static-memory-planner-for-mlir-a-gsoc-2026-journey-89907.md>)

Original publisher: [Read original article](<https://blog.llvm.org/posts/2026-08-24-gsoc-2026-static-memory-planner/>)

Author: Krish Gupta

Published: 2026-10-19T00:00:00Z

Content type: article

Language: en

Sources: [LLVM Project](<https://devfeed.tech/sources/the-llvm-project-blog.md>)

Topics: [mlir](<https://devfeed.tech/topics/mlir.md>), [memory handling](<https://devfeed.tech/topics/memory-handling.md>), [memory pool](<https://devfeed.tech/topics/memory-pool.md>), [Memory Safety](<https://devfeed.tech/topics/memory-safety.md>)

Tags: [buffer](<https://devfeed.tech/tags/buffer.md>), [bufferization](<https://devfeed.tech/tags/bufferization.md>), [compilation](<https://devfeed.tech/tags/compilation.md>), [gsoc](<https://devfeed.tech/tags/gsoc.md>), [heap](<https://devfeed.tech/tags/heap.md>), [llvm](<https://devfeed.tech/tags/llvm.md>), [llvm-foundation](<https://devfeed.tech/tags/llvm-foundation.md>), [memory](<https://devfeed.tech/tags/memory.md>), [memory-planning](<https://devfeed.tech/tags/memory-planning.md>), [mlir](<https://devfeed.tech/tags/mlir.md>), [performance](<https://devfeed.tech/tags/performance.md>), [process](<https://devfeed.tech/tags/process.md>), [time](<https://devfeed.tech/tags/time.md>), [transformation](<https://devfeed.tech/tags/transformation.md>), [types](<https://devfeed.tech/tags/types.md>)

### AI overview

A Google Summer of Code contributor describes an MLIR static memory planning pass that replaces separate heap allocations with a compile-time arena and views. It traces the pass's development through alias analysis, control-flow cases, testing, and upstream review, and notes that current planning is limited to allocations in a function's entry block.

### Source excerpt

Hi, I am Krish Gupta. Over the summer I worked with the LLVM Foundation as partof Google Summer of Code 2026on building a static memory planner for MLIR, mentored byMatthias Springer andJaved Absar. This post walks through what webuilt, why it matters, and what the iterative process of landing it upstreamactually looked like. The Problem After bufferization, buffer lifetimes in MLIR IR are fully explicit: thecompiler knows exactly when each allocation starts and ends (for staticshapes; runtime-dependent allocations are handled conservatively). We use thisinformation to eliminate redundant heap allocations through a static memoryplanner. This matters for accelerator-oriented compilation. On many targets (embeddedCPUs, DSPs, custom accelerators) heap allocation is either not allowed orslow, because access to main memory is expensive. Even where heap allocationis available, individual small allocations hurt performance throughfragmentation and cache pressure. What you want instead is a single staticarena whose layout is computed at compile time: // Before: three separate heap allocations%a = memref.alloc() : memref<1024xf32> // 4096 bytes%b = memref.alloc() : memref<512xf32> // 2048 bytesmemref.dealloc %a : memref<1024xf32>memref.dealloc %b : memref<512xf32>// After: one arena, two views%arena = memref.alloc() : memref<6144xi8>%a = memref.view %arena[0][] : memref<6144xi8> to memref<1024xf32>%b = memref.view %arena[4096][]: memref<6144xi8> to memref<512xf32>// ... uses of %a and %b ...memref.dealloc %arena : memref<6144xi8> The arena is memref<Nxi8> so it can hold buffers of different datatypes.memref.view reinterprets slices back to their original types with zerooverhead. This is the core transformation the planner performs. How the Pass Works The pass is a FunctionOpInterface pass: it runs per function and processesthe entire function body in six steps: Step 1: Collect candidates: walk all memref.alloc ops, find their deallocs via alias analysis, apply eligibility ch

## GSoC 2026: Improving lit

DevFeed: [GSoC 2026: Improving lit](<https://devfeed.tech/articles/gsoc-2026-improving-lit-85144.md>)

Original publisher: [Read original article](<https://blog.llvm.org/posts/2026-gsoc-improving-lit/>)

Author: Prasoon Kumar (prasoon054)

Published: 2026-10-12T00:00:00Z

Content type: article

Language: en

Sources: [LLVM Project](<https://devfeed.tech/sources/the-llvm-project-blog.md>)

Topics: [Test automation](<https://devfeed.tech/topics/test-automation.md>), [Benchmark](<https://devfeed.tech/topics/benchmark.md>), [Test-driven development](<https://devfeed.tech/topics/tdd.md>), [CI/CD](<https://devfeed.tech/topics/cicd.md>)

Tags: [accelerators](<https://devfeed.tech/tags/accelerators.md>), [compiler](<https://devfeed.tech/tags/compiler.md>), [gpus](<https://devfeed.tech/tags/gpus.md>), [gsoc](<https://devfeed.tech/tags/gsoc.md>), [ipc](<https://devfeed.tech/tags/ipc.md>), [lit](<https://devfeed.tech/tags/lit.md>), [llvm](<https://devfeed.tech/tags/llvm.md>), [overhead](<https://devfeed.tech/tags/overhead.md>), [parallel](<https://devfeed.tech/tags/parallel.md>), [performance](<https://devfeed.tech/tags/performance.md>), [python](<https://devfeed.tech/tags/python.md>), [shell](<https://devfeed.tech/tags/shell.md>), [syscall](<https://devfeed.tech/tags/syscall.md>), [systems](<https://devfeed.tech/tags/systems.md>), [test](<https://devfeed.tech/tags/test.md>), [testing](<https://devfeed.tech/tags/testing.md>), [toolchains](<https://devfeed.tech/tags/toolchains.md>)

### AI overview

A Google Summer of Code contributor describes performance and correctness work on lit, LLVM's test runner. Changes included modernizing Python code, moving shell utilities in process, fixing pipeline behavior, and improving executor scheduling. Benchmarks showed gains for selected suites, while experiments with threads and an asyncio engine exposed tradeoffs related to GIL contention and core count.

### Source excerpt

This summer I worked on improving lit, the LLVM Integrated Tester, as part of Google Summer of Code 2026. I got interested in compilers after seeing how much heavy lifting happens underneath a single line of code, especially on parallel accelerators like GPUs.Two courses at IIT Bombay, SysML and Advanced Computer Architecture, turned that from a passing interest into something I actually wanted to work on.I'd like to eventually move toward compilers or microarchitecture for parallel compute engines as a career, and LLVM felt like the right place to start: it's the compiler infrastructure behind a large share of the toolchains people actually use, so performance work here doesn't stay contained to one project.lit specifically appealed to me because the problems in it turned out to be systems problems, process scheduling, IPC, syscall overhead, GIL contention, not surface-level scripting fixes, which is exactly the kind of low-level work I wanted hands-on experience with before jumping into compiler internals directly. My mentors were Aiden Grossman, Paul Kirth, and Petr Hosek. The Project lit is LLVM's test runner.RUN: lines look like shell commands, but lit's own internal shell parses and runs them itself.A 2024 RFC made that the default everywhere, arguing it's faster and more consistent across platforms than spawning an actual shell process for every line (RFC).The option to spawn a shell process instead still exists in the code, but now raises an error unless explicitly forced, and is on track for removal.By the time I started this project, it was lit's own Python code, not a spawned shell process, parsing and executing every RUN: line, in every subproject in the monorepo, under ninja check-* (lit also runs a smaller set of tests in GoogleTest's format, which skip RUN: entirely).None of that, parsing and executing RUN: lines, compiles or checks anything on its own.It's the overhead sitting between a developer pushing a change and finding out whether it passed.lit

## GSOC26: Sharing LLVM-libc's floating-point routines with compiler-rt

DevFeed: [GSOC26: Sharing LLVM-libc's floating-point routines with compiler-rt](<https://devfeed.tech/articles/gsoc26-sharing-llvm-libc-s-floating-point-routines-with-compiler-rt-64734.md>)

Original publisher: [Read original article](<https://blog.llvm.org/posts/2026-08-24-gsoc-sharing-libc-with-compiler-rt/>)

Author: Mohamed Emad

Published: 2026-10-05T00:00:00Z

Content type: article

Language: en

Sources: [LLVM Project](<https://devfeed.tech/sources/the-llvm-project-blog.md>)

Topics: [Compiler](<https://devfeed.tech/topics/compiler.md>), [LLVM](<https://devfeed.tech/topics/llvm.md>), [floating-point](<https://devfeed.tech/topics/floating-point.md>)

Tags: [assembly](<https://devfeed.tech/tags/assembly.md>), [build](<https://devfeed.tech/tags/build.md>), [builtins](<https://devfeed.tech/tags/builtins.md>), [compiler](<https://devfeed.tech/tags/compiler.md>), [compiler-rt](<https://devfeed.tech/tags/compiler-rt.md>), [floating-point](<https://devfeed.tech/tags/floating-point.md>), [gsoc](<https://devfeed.tech/tags/gsoc.md>), [hardware](<https://devfeed.tech/tags/hardware.md>), [headers](<https://devfeed.tech/tags/headers.md>), [libc](<https://devfeed.tech/tags/libc.md>), [llvm](<https://devfeed.tech/tags/llvm.md>), [math](<https://devfeed.tech/tags/math.md>)

### AI overview

The LLVM project describes sharing LLVM-libc floating-point math routines with compiler-rt, replacing duplicated soft-float implementations with thin wrappers that forward to shared routines. The approach is opt-in through a CMake macro, and the article covers implementation challenges involving recursive builtin calls, 16-bit formats, x87 extended precision, symbol conflicts, and generating wrappers, build entries, and tests. Benchmarking and optimization are planned, while some comparison and conversion work remains under review.

### Source excerpt

Introduction Hello LLVM community! I am Mohamed Emad, CSE student at Zagazig University, Egypt. This summer I worked on the next step of the Hand-in-Hand project, an effort that began in 2024 with #91651 to make LLVM-libc a shared foundation that the rest of LLVM can build on. My part was to share LLVM-libc's floating-point math routines with compiler-rt. It replaces compiler-rt's existing builtins, which were written from scratch in C and assembly with a separate implementation per architecture, with LLVM-libc's code, which is well-tested and well-maintained. Overview When a program targets hardware without a floating-point unit, the compilercannot emit an fadd or fcvt instruction. Instead it emits a call to a helperroutine: __adddf3 to add two doubles, __fixdfsi to convert a double to anint, __letf2 to compare two float128s. compiler-rt's builtins libraryships these routines, and it has carried its own soft-float implementations ofthem for years. LLVM-libc implements the same math independently, with correctly-rounded resultsand a large test suite behind it. So the project starts from an awkward fact:LLVM keeps two separate soft-float implementations of the same operations. Twocopies drift apart, each needs its own review and testing, and a bug fixed inone rarely reaches the other. compiler-rt's versions are also older and lessrigorously verified than libc's. This project gives compiler-rt one source of truth. LLVM-libc exposes itsroutines as freestanding headers under LIBC_NAMESPACE::shared::, and eachcompiler-rt builtin becomes a thin wrapper that forwards to the matching libcroutine. A single .c file such as truncdfsf2.c is swapped for atruncdfsf2.cpp that calls shared::truncdfsf2. The swap happens through aCMake macro, use_libc_builtin(), gated on COMPILER_RT_USE_LIBC_MATH, sodistributors who want the libc-backed path opt in and everyone else keeps theexisting behavior. Figure 1: Two soft-float implementations of the same operation become one shared LLVM-libc

## Remembering Johannes Doerfert

DevFeed: [Remembering Johannes Doerfert](<https://devfeed.tech/articles/remembering-johannes-doerfert-59724.md>)

Original publisher: [Read original article](<https://blog.llvm.org/posts/2026-09-24-rememberingjohannesdoerfert/>)

Author: Tanya Lattner

Published: 2026-09-24T00:00:00Z

Content type: news

Language: en

Sources: [LLVM Project](<https://devfeed.tech/sources/the-llvm-project-blog.md>)

Topics: [Compiler](<https://devfeed.tech/topics/compiler.md>), [LLVM](<https://devfeed.tech/topics/llvm.md>), [Optimization](<https://devfeed.tech/topics/optimization.md>), [High-Performance Computing](<https://devfeed.tech/topics/high-performance-computing.md>), [GPU](<https://devfeed.tech/topics/gpu.md>), [toolchain](<https://devfeed.tech/topics/toolchain.md>)

Tags: [2026](<https://devfeed.tech/tags/2026.md>), [community](<https://devfeed.tech/tags/community.md>), [compiler](<https://devfeed.tech/tags/compiler.md>), [compiler-research](<https://devfeed.tech/tags/compiler-research.md>), [gpu](<https://devfeed.tech/tags/gpu.md>), [high-performance-computing](<https://devfeed.tech/tags/high-performance-computing.md>), [in-memoriam](<https://devfeed.tech/tags/in-memoriam.md>), [llvm](<https://devfeed.tech/tags/llvm.md>), [openmp](<https://devfeed.tech/tags/openmp.md>)

### AI overview

An LLVM post remembers Johannes Doerfert, a major contributor to compiler research and high-performance computing, highlighting his work on the Attributor framework, OpenMP GPU offloading, Polly, and polyhedral optimization.

### Source excerpt

It is with great sadness that we share the news of the passing of Johannes Doerfert, on September 17, 2026, at the age of 36, after a battle with cancer. Johannes was one of the most prolific and respected contributors to the LLVM compiler project, and his loss will be deeply felt. Johannes was born on November 5, 1989. He earned his Ph.D. in computer science from Saarland University in Saarbrücken, Germany, in 2018, where his research focused on applying polyhedral compiler technologies to low-level code. He had been an active LLVM contributor since 2014, working in the compiler design lab of Prof. Sebastian Hack, and became a core developer on the Polly polyhedral-optimization project as early as 2012. Over the following decade, Johannes built a career at the intersection of compiler research and high-performance computing, most recently as a researcher focused on OpenMP, LLVM, and parallel program optimization. Contributions to LLVM Johannes's worked on many parts of the LLVM Project, and these are just a few of his contributions: The Attributor framework. Johannes designed and championed the Attributor, LLVM's versatile inter-procedural fixpoint iteration framework for deducing and propagating function and argument attributes across a program. He introduced it to the community at the 2019 LLVM Developers' Meeting, and it has since become an important piece of LLVM's interprocedural optimization infrastructure. OpenMP and GPU offloading. Johannes became LLVM's code owner for OpenMP target offloading in 2021, leading the compiler and runtime support that lets OpenMP programs run efficiently on GPUs across NVIDIA, AMD, and Intel hardware. His work spanned the OpenMP runtime, just-in-time compilation and link-time optimization for target offloading, and techniques for near-zero-overhead GPU execution. Polly and polyhedral optimization. Early in his career, Johannes was a core developer of Polly, LLVM's polyhedral loop optimization infrastructure, and published resea

## GSoC 2026: Improving HLSL Support in clangd

DevFeed: [GSoC 2026: Improving HLSL Support in clangd](<https://devfeed.tech/articles/gsoc-2026-improving-hlsl-support-in-clangd-55678.md>)

Original publisher: [Read original article](<https://blog.llvm.org/posts/gsoc_2026_hlsl_clangd/>)

Author: Maria Fernanda Guimarães

Published: 2026-09-21T00:00:00Z

Content type: article

Language: en

Sources: [LLVM Project](<https://devfeed.tech/sources/the-llvm-project-blog.md>)

Topics: [shaders](<https://devfeed.tech/topics/shaders.md>), [GPU](<https://devfeed.tech/topics/gpu.md>), [C++](<https://devfeed.tech/topics/c-plus-plus.md>), [clang](<https://devfeed.tech/topics/clang.md>), [Compiler](<https://devfeed.tech/topics/compiler.md>), [ide](<https://devfeed.tech/topics/ide.md>), [Programming](<https://devfeed.tech/topics/programming.md>)

Tags: [architecture](<https://devfeed.tech/tags/architecture.md>), [c-plus-plus](<https://devfeed.tech/tags/c-plus-plus.md>), [clang](<https://devfeed.tech/tags/clang.md>), [clangd](<https://devfeed.tech/tags/clangd.md>), [code](<https://devfeed.tech/tags/code.md>), [code-completion](<https://devfeed.tech/tags/code-completion.md>), [compiler](<https://devfeed.tech/tags/compiler.md>), [diagnostics](<https://devfeed.tech/tags/diagnostics.md>), [gpu](<https://devfeed.tech/tags/gpu.md>), [gsoc](<https://devfeed.tech/tags/gsoc.md>), [hlsl](<https://devfeed.tech/tags/hlsl.md>), [ide](<https://devfeed.tech/tags/ide.md>), [navigation](<https://devfeed.tech/tags/navigation.md>), [process](<https://devfeed.tech/tags/process.md>), [programming](<https://devfeed.tech/tags/programming.md>), [shader-programming](<https://devfeed.tech/tags/shader-programming.md>)

### AI overview

This article describes a Google Summer of Code 2026 project to improve HLSL support in clangd. It explains how HLSL-specific constructs expose gaps in IDE features such as hover, code completion, navigation, and diagnostics, and how the project analyzes whether those gaps belong in clangd, configuration, or earlier compiler infrastructure.

### Source excerpt

GSoC 2026: Improving HLSL Support in clangd HLSL (High-Level Shading Language) is a C++-like language used for GPU shader programming. Clang already parses HLSL and represents many of its constructs in the AST. clangd, however, reuses its C/C++ infrastructure to provide IDE features such as hover, code completion, diagnostics, and navigation. Clang may fully understand an HLSL construct, while clangd does not necessarily know how to expose that information to the user. For example, HLSL has language-specific constructs such as semantic annotations, resource bindings, out/inout parameters, shader attributes, and vector and matrix swizzles. These constructs do not always have direct equivalents in standard C++, so the existing clangd infrastructure does not automatically provide the expected editor experience. The goal of my Google Summer of Code 2026 project was to identify these gaps and improve HLSL support in clangd. I first wanted to understand the current state of HLSL support, identify where the problems were coming from, and determine which solutions would fit best into the existing Clang and clangd architecture. The project followed this process: Gap Analysis | vInvestigation | vImplementation Ideas | v RFC | vCommunity Feedback | vGitHub Issues | vPull Requests Finding the Gaps The first phase of the project was a to do a gap analysis. I created isolated HLSL test cases covering different categories of language constructs and tested them using several clangd features: hover, code completion, go-to-definition, and diagnostics. When the behavior was unclear, I also inspected Clang's AST to determine whether the required information was already available to clangd. The goal was to distinguish between different kinds of problems. Some constructs were already represented correctly in the AST but were not exposed by clangd. Others involved configuration, while some problems originated earlier in the compiler pipeline. This distinction was important because the sol

## GSoC 2026: Extending Clang API Notes for C++: Overload-Specific Annotations for Functions and Methods

DevFeed: [GSoC 2026: Extending Clang API Notes for C++: Overload-Specific Annotations for Functions and Methods](<https://devfeed.tech/articles/gsoc-2026-extending-clang-api-notes-for-c-overload-specific-annotations-for-functions-and-methods-43127.md>)

Original publisher: [Read original article](<https://blog.llvm.org/posts/2026-08-21-gsoc-clang-api-notes-overloads/>)

Author: Dominic Stöcker

Published: 2026-09-14T00:00:00Z

Content type: article

Language: en

Sources: [LLVM Project](<https://devfeed.tech/sources/the-llvm-project-blog.md>)

Topics: [clang](<https://devfeed.tech/topics/clang.md>), [C++](<https://devfeed.tech/topics/c-plus-plus.md>), [API](<https://devfeed.tech/topics/api.md>), [interoperability](<https://devfeed.tech/topics/interoperability.md>), [Swift](<https://devfeed.tech/topics/swift.md>), [YAML](<https://devfeed.tech/topics/yaml.md>), [Parsing](<https://devfeed.tech/topics/parsing.md>), [selectors](<https://devfeed.tech/topics/selectors.md>), [function](<https://devfeed.tech/topics/function.md>)

Tags: [api](<https://devfeed.tech/tags/api.md>), [api-notes](<https://devfeed.tech/tags/api-notes.md>), [apis](<https://devfeed.tech/tags/apis.md>), [c](<https://devfeed.tech/tags/c.md>), [c-plus-plus](<https://devfeed.tech/tags/c-plus-plus.md>), [clang](<https://devfeed.tech/tags/clang.md>), [gsoc](<https://devfeed.tech/tags/gsoc.md>), [objective-c](<https://devfeed.tech/tags/objective-c.md>), [parsing](<https://devfeed.tech/tags/parsing.md>), [selectors](<https://devfeed.tech/tags/selectors.md>), [swift](<https://devfeed.tech/tags/swift.md>), [yaml](<https://devfeed.tech/tags/yaml.md>)

### AI overview

A Google Summer of Code 2026 project extended Clang API Notes to support annotations for individual overloaded C++ functions and methods. The work introduced YAML-based overload selectors and covered parsing, serialization, declaration lookup, semantic analysis, type normalization, diagnostics, and Swift interoperability.

### Source excerpt

Hi! I'm Dominic Stöcker, and during Google Summer of Code 2026 I worked on extending Clang API Notes for C++ with overload-specific annotations for functions and methods. My mentors were Gábor Horváth, John Hui, and Egor Zhdan. This project was originally accepted as a small, 8-week project. As the implementation scope grew, it was expanded to a large, 12-week project. I was interested in this project because it connects Clang's semantic analysis with Swift interoperability. What made the project especially interesting to me was that a concise user-facing YAML extension had to be connected to Clang's internal model of declarations, types, overloads, and source-level type spelling. The goal of the project was to let API Notes target individual C++ function and method overloads. The work covered the public YAML design, parsing, binary serialization, declaration lookup, Sema integration, type normalization, diagnostics, and member-function object qualifiers. Background API Notes allow additional information to be attached to declarations without modifying their original source headers. They are used in particular to refine how C, Objective-C, and C++ APIs are exposed to Swift. Previously, an API Notes entry could identify a C++ function or method primarily by name. This is not sufficient when several overloads share that name: struct Widget { void setValue(int); void setValue(double);}; A name-only entry for setValue applies to the whole overload set, so it cannot assign different annotations to setValue(int) and setValue(double). The main challenge was therefore not only to select individual overloads, but to do so without changing the behavior of existing name-only API Notes files. Selecting C++ Overloads API Notes are structured according to the kind of declaration they apply to, like Functions, Tags, and Methods. The C++ overload selectors I designed for my project extend the Functions and Methods schemas with an optional Where block that narrows a name-based looku

## GSoC 2025: Advanced symbol resolution for Clang-Repl

DevFeed: [GSoC 2025: Advanced symbol resolution for Clang-Repl](<https://devfeed.tech/articles/gsoc-2025-advanced-symbol-resolution-for-clang-repl-43124.md>)

Original publisher: [Read original article](<https://blog.llvm.org/posts/2025-11-11-advanced-symbol-resolution-for-clang-repl/>)

Author: Sahil Patidar

Published: 2026-01-19T00:00:00Z

Content type: article

Language: en

Sources: [LLVM Project](<https://devfeed.tech/sources/the-llvm-project-blog.md>)

Topics: [clang](<https://devfeed.tech/topics/clang.md>), [C++](<https://devfeed.tech/topics/c-plus-plus.md>), [LLVM](<https://devfeed.tech/topics/llvm.md>), [JIT](<https://devfeed.tech/topics/jit.md>), [Library](<https://devfeed.tech/topics/library.md>), [Code](<https://devfeed.tech/topics/code.md>)

Tags: [2025](<https://devfeed.tech/tags/2025.md>), [api](<https://devfeed.tech/tags/api.md>), [c-plus-plus](<https://devfeed.tech/tags/c-plus-plus.md>), [clang](<https://devfeed.tech/tags/clang.md>), [clang-repl](<https://devfeed.tech/tags/clang-repl.md>), [code](<https://devfeed.tech/tags/code.md>), [compilation](<https://devfeed.tech/tags/compilation.md>), [execution](<https://devfeed.tech/tags/execution.md>), [gsoc](<https://devfeed.tech/tags/gsoc.md>), [jit](<https://devfeed.tech/tags/jit.md>), [library](<https://devfeed.tech/tags/library.md>), [llvm](<https://devfeed.tech/tags/llvm.md>), [orc-jit](<https://devfeed.tech/tags/orc-jit.md>), [repl](<https://devfeed.tech/tags/repl.md>)

### AI overview

This article describes a Google Summer of Code project that adds advanced symbol resolution to Clang-Repl, an interactive C++ interpreter built on LLVM's ORC JIT. The project introduces a library-resolution API that locates libraries containing unresolved symbols, enabling more seamless runtime handling without manual library loading.

### Source excerpt

Introduction Hello! I'm Sahil Patidar, and this summer I had the opportunity to participate in Google Summer of Code (GSoC) 2025 with the LLVM Organization.My project focused on enhancing ORC-JIT and Clang-Repl by introducing a new feature for advanced symbol resolution, aimed at improving runtime symbol handling and flexibility. Mentors: Vassil Vassilev, Aaron Jomy Overview of the Project Clang-Repl is an interactive C++ interpreter built on top of LLVM's ORC JIT, enabling incremental compilation and execution.However, when user code references symbols from external libraries, those libraries must currently be loaded manually. This happens because ORC JIT does not automatically resolve symbols from libraries that haven't been loaded yet. To overcome this limitation, my project introduces an automatic library resolver for unresolved symbols in ORC JIT, improving Clang-Repl's runtime by making external symbol handling seamless and user-friendly. Project Goals The main goal of my project was to design and implement a new Library-Resolution API for ORC-JIT.This API acts as a smart symbol resolver -- when ORC-JIT encounters an unresolved symbol, it can call this API to find where the symbol exists and which library provides it. The next step is to integrate this API into ORC-JIT, so that Clang-Repl can automatically use it to handle missing symbols without requiring manual library loading. Library-Resolution: Smarter Symbol Resolver During my GSoC project, one of the major components I worked on was Library-Resolution -- an API we re-designed and re-implemented based on Cling's original library-resolver. In simple terms, Library-Resolution acts as a smart library resolver.It doesn't actually load libraries -- instead, it finds where the missing symbols (unresolved references) can be found and provides their correct library paths. This makes it a powerful helper when dealing with unresolved symbols during execution. How It Works When system (Orc-JIT or any) encounters an un

## Making LLVM Compilation Data Accessible: A Unified Visualization Tool for Compiler Artifacts

DevFeed: [Making LLVM Compilation Data Accessible: A Unified Visualization Tool for Compiler Artifacts](<https://devfeed.tech/articles/making-llvm-compilation-data-accessible-a-unified-visualization-tool-for-compiler-artifacts-43119.md>)

Original publisher: [Read original article](<https://blog.llvm.org/posts/2025-08-31-gsoc-llvm-advisor/>)

Author: Miguel Cárdenas

Published: 2025-12-08T00:00:00Z

Content type: article

Language: en

Sources: [LLVM Project](<https://devfeed.tech/sources/the-llvm-project-blog.md>)

Topics: [LLVM](<https://devfeed.tech/topics/llvm.md>), [Compiler](<https://devfeed.tech/topics/compiler.md>), [toolchain](<https://devfeed.tech/topics/toolchain.md>), [Optimization](<https://devfeed.tech/topics/optimization.md>), [dashboards](<https://devfeed.tech/topics/dashboards.md>), [JSON](<https://devfeed.tech/topics/json.md>), [Developer Tools](<https://devfeed.tech/topics/developer-tools.md>)

Tags: [build](<https://devfeed.tech/tags/build.md>), [compilation](<https://devfeed.tech/tags/compilation.md>), [compiler](<https://devfeed.tech/tags/compiler.md>), [developers](<https://devfeed.tech/tags/developers.md>), [google](<https://devfeed.tech/tags/google.md>), [gsoc](<https://devfeed.tech/tags/gsoc.md>), [llvm](<https://devfeed.tech/tags/llvm.md>), [offloading](<https://devfeed.tech/tags/offloading.md>), [optimization](<https://devfeed.tech/tags/optimization.md>), [tooling](<https://devfeed.tech/tags/tooling.md>), [visualization](<https://devfeed.tech/tags/visualization.md>)

### AI overview

An undergraduate Google Summer of Code project report describes LLVM Advisor, a prototype that unifies compilation artifacts such as optimization remarks, profiling information, and timing data. The tool collects and organizes these artifacts, stores them in JSON, and presents them through a web-based visualization interface.

### Source excerpt

This summer, I had the incredible opportunity to work on an LLVM project through Google Summer of Code 2025. As an undergraduate student passionate about compilers, I set out to tackle a problem that many LLVM developers face daily: the overwhelming nature of compilation data scattered across different flags, output formats, and locations. The Problem: Information Overload LLVM generates a wealth of valuable data during compilation-optimization, including optimization remarks, profiling information, timing data, and more. However, this information is often difficult to process and analyze, especially for developers new to LLVM or those working with offloading toolchains. The typical workflow involves: Searching through thousands of remarks using grep Manually correlating data across compilation units Trial-and-error debugging without data-driven insights Wrestling with different output formats and flags This fragmented approach makes it particularly challenging for newcomers to understand what's happening during compilation and how to optimize their code effectively. Project Goals The goal was to create a unified infrastructure that organizes, visualizes, and analyzes compilation data for the LLVM toolchain. Specifically, I aimed to: Make compiler data accessible to everyone, not just experts Reduce the frustration of searching through compilation artifacts Enable data-driven optimization decisions Create a foundation for advanced analysis tools Make offloading development more approachable What I Built Over the 12-week program, I developed a working prototype called LLVM Advisor that addresses these challenges through several key components: Compiler Wrapper Tool I created an easy-to-use wrapper (similar to ccache) that automatically collects all relevant compilation artifacts without requiring users to modify their build systems. The wrapper intelligently parses and organizes data into a structured format. Storage Layer The tool uses a JSON-based storage format th

## GSoC 2025: ClangIR upstreaming

DevFeed: [GSoC 2025: ClangIR upstreaming](<https://devfeed.tech/articles/gsoc-2025-clangir-upstreaming-43126.md>)

Original publisher: [Read original article](<https://blog.llvm.org/posts/2025-gsoc-clangir-upstreaming/>)

Author: Amr Hesham (amrdeveloper)

Published: 2025-12-01T00:00:00Z

Content type: article

Language: en

Sources: [LLVM Project](<https://devfeed.tech/sources/the-llvm-project-blog.md>)

Topics: [LLVM](<https://devfeed.tech/topics/llvm.md>), [mlir](<https://devfeed.tech/topics/mlir.md>), [c/c++](<https://devfeed.tech/topics/c-c-plus-plus.md>), [C++](<https://devfeed.tech/topics/c-plus-plus.md>), [Exception handling](<https://devfeed.tech/topics/exception-handling.md>)

Tags: [c-plus-plus](<https://devfeed.tech/tags/c-plus-plus.md>), [clang](<https://devfeed.tech/tags/clang.md>), [clangir](<https://devfeed.tech/tags/clangir.md>), [code](<https://devfeed.tech/tags/code.md>), [exception-handling](<https://devfeed.tech/tags/exception-handling.md>), [gsoc](<https://devfeed.tech/tags/gsoc.md>), [llvm](<https://devfeed.tech/tags/llvm.md>), [mlir](<https://devfeed.tech/tags/mlir.md>)

### AI overview

A Google Summer of Code 2025 project report describes upstreaming ClangIR, a high-level C/C++ representation implemented with MLIR between Clang's AST and LLVM IR. The work covered design improvements, built-in vector operations, complex-number operations, and C++ exception handling.

### Source excerpt

Hello everyone 👋! My name is Amr Hesham, and for Google Summer of Code 2025, I've been working on the ClangIR Upstreaming project. My mentors were Bruno Cardoso Lopes, Andy Kaylor and Erich Keane. Background ClangIR is a high-level representation in Clang that reflects aspects of the C/C++ languages and their extensions. It is implemented using MLIR and occupies a position between Clang's AST and LLVM IR. Starting from April 2024, the upstreaming process started to migrate the code from the incubator to the main LLVM repository. The ClangIR upstreaming process includes the following steps: Improve the design of ClangIR dialect operations, attributes, syntax and implementation details if needed. Align with LLVM coding standards and quality expectations. Implement missing features in the incubator and upstream it. Backport the new design/implementation from the LLVM repository to the incubator. Implement folders for ClangIR dialect operations. The goal of this project was to implement the following C/C++ features in the ClangIR project. Built-in VectorType (vector_size and ext_vector_type attributes) with operators and built-ins functions. ComplexType with operators and all -complex-range flag values to allow selecting different arithmatic calculation algorithms, for example, the SMITH, R. L. Algorithm 116: Complex division. Commun. ACM 5, 8 (1962). C++ Exception handling. What we did Over the coding period, I did the following. Builtin VectorType I have implemented support for all C/C++ operators for built-in VectorType that includes arithmetic, comparison, shifts and logical operators, also supporting using VectorType in many expressions, for example, index and ternary expression, and now we can compile C++ code successfully. Also, implemented folders for ClangIR VectorType operations to fold specific patterns. For example, in cir::VecExtractOp, if both the vector and the index are constant, we can fold that operation and replace it with the actual result. // Before

## GSoC 2025: Rich Disassembler for LLDB

DevFeed: [GSoC 2025: Rich Disassembler for LLDB](<https://devfeed.tech/articles/gsoc-2025-rich-disassembler-for-lldb-43120.md>)

Original publisher: [Read original article](<https://blog.llvm.org/posts/2025-08-gsoc-lldb-rich-disassembler/>)

Author: Abdullah Amin

Published: 2025-11-10T00:00:00Z

Content type: article

Language: en

Sources: [LLVM Project](<https://devfeed.tech/sources/the-llvm-project-blog.md>)

Topics: [debugging](<https://devfeed.tech/topics/debugging.md>), [LLVM](<https://devfeed.tech/topics/llvm.md>), [Developer Tools](<https://devfeed.tech/topics/developer-tools.md>), [Assembly](<https://devfeed.tech/topics/assembly.md>)

Tags: [code](<https://devfeed.tech/tags/code.md>), [debugger](<https://devfeed.tech/tags/debugger.md>), [debugging](<https://devfeed.tech/tags/debugging.md>), [developers](<https://devfeed.tech/tags/developers.md>), [gsoc](<https://devfeed.tech/tags/gsoc.md>), [lldb](<https://devfeed.tech/tags/lldb.md>), [llvm](<https://devfeed.tech/tags/llvm.md>)

### AI overview

A GSoC 2025 project extended LLDB with a rich disassembler that uses DWARF debug information to annotate machine instructions with source-level variable locations and lifetimes. The prototype adds variable tracking, register annotations, and portable API tests.

### Source excerpt

Hello! I'm Abdullah Amin, and this summer I had the exciting opportunity to participate in Google Summer of Code (GSoC) 2025 with the LLVM Compiler Infrastructure project. My project focused on extending LLDB with a Rich Disassembler that annotates machine instructions with source-level variable information. Mentors: Adrian Prantl and Jonas Devlieghere Project Background LLDB is LLVM's debugger, capable of source-level debugging across multiple platforms and architectures. While LLDB's disassembler shows machine instructions, it doesn't provide much insight into how variables from the original program map onto registers or memory. The goal of this project was to use DWARF debug information to enhance LLDB's disassembly with variable lifetime and location annotations. This allows developers to better understand what each register contains at a given point in time, and how variables flow across instructions. For example, instead of just seeing register usage: 0x100000f80 <+32>: movq (%rbx,%r15,8), %rdi ...the rich disassembler can add context: 0x100000f80 <+32>: movq (%rbx,%r15,8), %rdi ; i = r15 This makes it much easier to reason about code, especially in optimized builds. What We Accomplished Over the summer, I implemented a prototype that integrates DWARF variable location ranges into LLDB's disassembly pipeline. The key accomplishments are: DWARFExpressionEntry API Added a new helper (GetExpressionEntryAtAddress) to expose variable location ranges from DWARF debug info. PR: #144238 Register-Resident Variable Annotations Updated the disassembler to annotate instructions when variables enter, change, or leave registers. PR: #147460 Stateful Variable Tracking Extended Disassembler::PrintInstructions() to track live variable states across instructions, emitting transitions such as: var = RDI when a variable becomes live in a register var = <undef> when a variable goes out of scope PR: #152887 Portable Tests Added new LLDB API tests under lldb/test/API/functionalities/d

## GSoC 2025: Introducing an ABI Lowering Library

DevFeed: [GSoC 2025: Introducing an ABI Lowering Library](<https://devfeed.tech/articles/gsoc-2025-introducing-an-abi-lowering-library-43116.md>)

Original publisher: [Read original article](<https://blog.llvm.org/posts/2025-08-25-abi-library/>)

Author: Narayan Sreekumar (vortex73)

Published: 2025-11-03T00:00:00Z

Content type: article

Language: en

Sources: [LLVM Project](<https://devfeed.tech/sources/the-llvm-project-blog.md>)

Topics: [LLVM](<https://devfeed.tech/topics/llvm.md>), [Library](<https://devfeed.tech/topics/library.md>), [C](<https://devfeed.tech/topics/c.md>), [interoperability](<https://devfeed.tech/topics/interoperability.md>), [abstraction](<https://devfeed.tech/topics/abstraction.md>)

Tags: [2025](<https://devfeed.tech/tags/2025.md>), [abi](<https://devfeed.tech/tags/abi.md>), [c](<https://devfeed.tech/tags/c.md>), [clang](<https://devfeed.tech/tags/clang.md>), [codegen](<https://devfeed.tech/tags/codegen.md>), [gsoc](<https://devfeed.tech/tags/gsoc.md>), [interoperability](<https://devfeed.tech/tags/interoperability.md>), [library](<https://devfeed.tech/tags/library.md>), [llvm](<https://devfeed.tech/tags/llvm.md>), [sysv](<https://devfeed.tech/tags/sysv.md>), [type-system](<https://devfeed.tech/tags/type-system.md>)

### AI overview

An LLVM GSoC 2025 project extracts target-specific ABI lowering logic from Clang into a reusable library. The library introduces an independent ABI type system and maps frontend types to ABI types to support correct C interoperability across different calling conventions.

### Source excerpt

Introduction In this post I'm going to outline details about a new ABI lowering library I've been developing for LLVM as part of GSoC 2025! The aim was to extract the ABI logic from Clang and create a reusable library that any LLVM frontend can use for correct C interoperability. The Problem We're Solving At the start of the program, I wrote about the fundamental gap in LLVM's target abstraction. The promise is simple: frontends emit LLVM IR, and LLVM handles everything else. But this promise completely breaks down when it comes to Application Binary Interface (ABI) lowering. Every LLVM frontend that wants C interoperability has to reimplement thousands of lines of target-specific ABI logic. Here's what that looks like in practice: struct Point { float x, y; };struct Point add_points(struct Point a, struct Point b); Seems innocent enough, right? But generating correct LLVM IR for this requires knowing: Are the struct arguments passed in registers or memory? If in registers, what register class is used? Are multiple values packed into a single register? Is the struct returned in registers or using a hidden return parameter? The answer depends on subtle ABI rules that are target-specific, constantly evolving, and absolutely critical to get right. Miss one detail and you get silent memory corruption. This godbolt link shows the same simple struct using six different calling conventions across six different targets. And crucially: a frontend generating IR needs to know ALL of this before it can emit the right function signature. As I outlined in my earlier blog post, LLVM's type system simply can't express all the information needed for correct ABI decisions. Two otherwise identical structs with different explicit alignment attributes have different ABIs. __int128 and _BitInt(128) look similar but follow completely different rules. The Design Independent ABI Type System At the heart of the library is llvm::abi::Type, a type system designed specifically for ABI decisions

## GSoC 2025: Usability Improvements for the Undefined Behavior Sanitizer

DevFeed: [GSoC 2025: Usability Improvements for the Undefined Behavior Sanitizer](<https://devfeed.tech/articles/gsoc-2025-usability-improvements-for-the-undefined-behavior-sanitizer-43122.md>)

Original publisher: [Read original article](<https://blog.llvm.org/posts/2025-09-01-gsoc-ubsan-trap-messages/>)

Author: Anthony Tran

Published: 2025-10-20T00:00:00Z

Content type: article

Language: en

Sources: [LLVM Project](<https://devfeed.tech/sources/the-llvm-project-blog.md>)

Topics: [undefined\_behavior](<https://devfeed.tech/topics/undefined-behavior.md>), [debugging](<https://devfeed.tech/topics/debugging.md>), [C](<https://devfeed.tech/topics/c.md>), [C++](<https://devfeed.tech/topics/c-plus-plus.md>), [clang](<https://devfeed.tech/topics/clang.md>), [Objective-C](<https://devfeed.tech/topics/objective-c.md>), [Kernel](<https://devfeed.tech/topics/kernel.md>)

Tags: [2025](<https://devfeed.tech/tags/2025.md>), [c](<https://devfeed.tech/tags/c.md>), [c-plus-plus](<https://devfeed.tech/tags/c-plus-plus.md>), [clang](<https://devfeed.tech/tags/clang.md>), [codegen](<https://devfeed.tech/tags/codegen.md>), [debug](<https://devfeed.tech/tags/debug.md>), [gsoc](<https://devfeed.tech/tags/gsoc.md>), [improvements](<https://devfeed.tech/tags/improvements.md>), [kernel](<https://devfeed.tech/tags/kernel.md>), [objective-c](<https://devfeed.tech/tags/objective-c.md>), [sanitizer](<https://devfeed.tech/tags/sanitizer.md>), [undefined-behavior](<https://devfeed.tech/tags/undefined-behavior.md>)

### AI overview

This article reports on Google Summer of Code 2025 work to improve the usability of trapping Undefined Behavior Sanitizer (UBSan). It explains how trapping mode supports kernel, embedded, and production-hardening use cases, but previously made debugging undefined behavior difficult. The work improves the information available to developers when debugger execution stops on a sanitizer trap.

### Source excerpt

Introduction My name is Anthony and I had the pleasure of working on improving the Undefined Behavior Sanitizer this Google Summer of Code 2025. My mentors were Dan Liew and Michael Buch. Background Undefined Behavior Sanitizer (UBSan) is a tool for detecting a subset of the undefined behaviors in the C, C++, and Objective-C languages at runtime. This project focused mainly on the trapping variant of UBSan, which is evoked through -fsanitize-trap=<...> along with -fsanitize=<...>. Trapping UBSan is a lighter-weight version of UBSan because upon detection of undefined behavior a trap instruction is executed rather than calling into a runtime library to handle the undefined behavior. This makes it more appealing for kernel, embedded, and production hardening use cases. For cases of undefined behavior that can be detected by UBSan, check out the official clang documentation. An issue with trapping UBSan prior to my work was that it was much harder to debug undefined behavior when it is detected when compared to the non-trapping mode. To illustrate this consider this C program that reads integers from the command line arguments and adds them. #include <stdlib.h>#include <stdio.h>int add(int a, int b) { return a + b;}int main(int argc, const char** argv) { if (argc < 3) return 1; int a = atoi(argv[1]); int b = atoi(argv[2]); int result = add(a, b); printf("Added %d + %d = %d\n", a, b, result); return 0;} If this program is compiled and executed using UBSan with its userspace runtime it provides helpful output diagnosing the problem and also allows execution to continue. $ bin/clang -fsanitize=undefined add.c -g -o add && ./add 2147483647 1add.c:5:13: runtime error: signed integer overflow: 2147483647 + 1 cannot be represented in type 'int'SUMMARY: UndefinedBehaviorSanitizer: undefined-behavior add.c:5:13 Added 2147483647 + 1 = -2147483648 In contrast when using UBSan in trapping mode the program immediately terminates when undefined behavior is detected as shown below. $

## GSoC 2025 - Support simple C++20 modules use from the Clang driver without a build system

DevFeed: [GSoC 2025 - Support simple C++20 modules use from the Clang driver without a build system](<https://devfeed.tech/articles/gsoc-2025-support-simple-c-20-modules-use-from-the-clang-driver-without-a-build-system-43121.md>)

Original publisher: [Read original article](<https://blog.llvm.org/posts/2025-08-gsoc-modules-driver/>)

Author: Naveen Seth Hanig

Published: 2025-10-06T00:00:00Z

Content type: article

Language: en

Sources: [LLVM Project](<https://devfeed.tech/sources/the-llvm-project-blog.md>)

Topics: [modules](<https://devfeed.tech/topics/modules.md>), [clang](<https://devfeed.tech/topics/clang.md>), [C++](<https://devfeed.tech/topics/c-plus-plus.md>), [builds](<https://devfeed.tech/topics/builds.md>)

Tags: [build](<https://devfeed.tech/tags/build.md>), [build-system](<https://devfeed.tech/tags/build-system.md>), [c-plus-plus](<https://devfeed.tech/tags/c-plus-plus.md>), [clang](<https://devfeed.tech/tags/clang.md>), [code](<https://devfeed.tech/tags/code.md>), [library](<https://devfeed.tech/tags/library.md>), [make](<https://devfeed.tech/tags/make.md>), [modules](<https://devfeed.tech/tags/modules.md>), [scope](<https://devfeed.tech/tags/scope.md>)

### AI overview

This post describes a Google Summer of Code project adding native support for simple Clang and C++20 named modules in the Clang driver without requiring a build system. It covers module dependency scanning, build ordering, standard library module imports, and implementation challenges.

### Source excerpt

Hi, my name is Naveen. For Google Summer of Code 2025, I've been working on adding native support for simple Clang and C++20 named module use from the Clang driver.This post outlines the project and its current status. My mentor for this project was Michael Spencer. Background Modules solve many of the long-standing problems with the traditional header-based way of sharing code. They prevent leaking macros, let you explicitly choose what to export, and can improve compile time at scale. However, because modules must be precompiled before use, builds that rely on them need to schedule compilations in the right order, according to their imports. At the moment, Clang's driver lacks native support to do this, which makes even simple tests or tiny programs using modules hard to compile without first setting up a build system. Goals The goal of this project is to extend the build system in Clang's driver to natievly support simple use of Clang or C++20 named modules, by integrating Clang's existing support for module dependency scanning. This should also support importing the C++ Standard library modules std and std.compat, and add no overhead to cases where modules are not used. With the feature fully implemented, the following example should compile without any issue: clang++ -std=c++23 main.cpp A.cpp -fmodules-driver -fmodules -fmodule-map-file=module.modulemap // main.cpp#include "MyLib.h"import std;import A;auto main() -> int { std::println("{}", make_greeting("modules")); std::println("The answer is: {}", get_answer());} // A.cppexport module A;import std;export auto make_greeting(std::string_view Name) -> std::string { return std::format("Hello, {}!", Name);} // module.modulemapmodule MyLib { header "MyLib.h" export *} // MyLib.hauto get_answer() -> int { return 42; } Although one of the main advantages of modules is that they can be precompiled once and reused for future uses, support for caching was not included in the scope of this GSoC project. Design Overview

## GSoC 2025: Bfloat16 in LLVM libc

DevFeed: [GSoC 2025: Bfloat16 in LLVM libc](<https://devfeed.tech/articles/gsoc-2025-bfloat16-in-llvm-libc-43123.md>)

Original publisher: [Read original article](<https://blog.llvm.org/posts/2025-09-10-bfloat16-in-llvm-libc/>)

Author: Krishna Pandey

Published: 2025-09-29T00:00:00Z

Content type: article

Language: en

Sources: [LLVM Project](<https://devfeed.tech/sources/the-llvm-project-blog.md>)

Topics: [LLVM](<https://devfeed.tech/topics/llvm.md>), [floating-point](<https://devfeed.tech/topics/floating-point.md>), [Hardware](<https://devfeed.tech/topics/hardware.md>), [Jule](<https://devfeed.tech/topics/jule.md>)

Tags: [2025](<https://devfeed.tech/tags/2025.md>), [arm](<https://devfeed.tech/tags/arm.md>), [c-plus-plus-23](<https://devfeed.tech/tags/c-plus-plus-23.md>), [floating-point](<https://devfeed.tech/tags/floating-point.md>), [gsoc](<https://devfeed.tech/tags/gsoc.md>), [hardware](<https://devfeed.tech/tags/hardware.md>), [libc](<https://devfeed.tech/tags/libc.md>), [llvm](<https://devfeed.tech/tags/llvm.md>), [math](<https://devfeed.tech/tags/math.md>), [risc-v](<https://devfeed.tech/tags/risc-v.md>), [x86](<https://devfeed.tech/tags/x86.md>)

### AI overview

This article describes a GSoC project that added BFloat16 support to LLVM libc. It covers the type, generic correctly rounded math functions, supported architectures, additional comparison and higher math functions, limitations, and planned work.

### Source excerpt

Introduction BFloat16 is a 16-bit floating-point format, introduced by Google and standardized in C++23 as std::bfloat16_t. It uses 1 sign bit, 8 exponent bits (the same as float), and 7 mantissa bits. This configuration allows BFloat16 to represent a much wider dynamic range than IEEE binary16 (~3x10^38 values compared to 65,504), though with lower precision. BFloat16 has become popular in AI and machine learning use-cases where it offers significant performance advantages over IEEE binary32 while preserving its approximate dynamic range. The goal of this project was to implement the BFloat16 type in LLVM libc along with the basic math functions like fabsbf16, fmaxbf16, etc. We also want all functions to be generic (platform-independent) and correctly rounded for all rounding modes. What was done BFloat16 type was added to LLVM libc (libc/src/__support/FPUtil/bfloat16.h) #144463. All 70 expected basic math functions for bfloat16 were implemented, using a generic approach that supports all libc supported architectures (ARM, RISC-V, GPUs, x86, Darwin) (see table below). Implemented two additional basic math functions: iscanonicalbf16 and issignalingbf16. Implemented higher math functions: sqrtbf16 #156654 and log_bf16 #157811 (open). Comparison operations for the FPBits class were added #144983. Basic Math FunctionPRfabsbf16#148398ceilbf16, floorbf16, roundbf16, roundevenbf16, truncbf16#152352bf16add, bf16addf, bf16addl, bf16addf128, bf16sub, bf16subf, bf16subl, bf16subf128#152774fmaxbf16, fminbf16#152782bf16mul, bf16mulf, bf16mull, bf16mulf128#152847fmaximumbf16, fmaximum_magbf16, fmaximum_mag_numbf16, fmaximum_numbf16, fminimumbf16, fminimum_magbf16, fminimum_mag_numbf16, fminimum_numbf16#152881bf16div, bf16divf, bf16divl, bf16divf128#153191bf16fma, bf16fmaf, bf16fmal, bf16fmaf128#153231llrintbf16, llroundbf16, lrintbf16, lroundbf16, nearbyintbf16, rintbf16#153882fromfpbf16, fromfpxbf16, ufromfpbf16, ufromfpxbf16#153992nextafterbf16, nextdownbf16, nexttowardbf16, n

## GSoC 2025: Improving Core Clang-Doc Functionality

DevFeed: [GSoC 2025: Improving Core Clang-Doc Functionality](<https://devfeed.tech/articles/gsoc-2025-improving-core-clang-doc-functionality-43125.md>)

Original publisher: [Read original article](<https://blog.llvm.org/posts/2025-gsoc-clang-doc/>)

Author: Erick Velez (evelez7)

Published: 2025-09-22T00:00:00Z

Content type: article

Language: en

Sources: [LLVM Project](<https://devfeed.tech/sources/the-llvm-project-blog.md>)

Topics: [clang](<https://devfeed.tech/topics/clang.md>), [Documentation](<https://devfeed.tech/topics/documentation.md>), [software-development](<https://devfeed.tech/topics/software-development.md>), [C++](<https://devfeed.tech/topics/c-plus-plus.md>), [Markdown](<https://devfeed.tech/topics/markdown.md>), [LLVM](<https://devfeed.tech/topics/llvm.md>), [format](<https://devfeed.tech/topics/format.md>), [JSON](<https://devfeed.tech/topics/json.md>), [Code generation](<https://devfeed.tech/topics/code-generation.md>), [YAML](<https://devfeed.tech/topics/yaml.md>), [HTML](<https://devfeed.tech/topics/html.md>)

Tags: [2025](<https://devfeed.tech/tags/2025.md>), [architecture](<https://devfeed.tech/tags/architecture.md>), [c-plus-plus](<https://devfeed.tech/tags/c-plus-plus.md>), [clang](<https://devfeed.tech/tags/clang.md>), [clang-doc](<https://devfeed.tech/tags/clang-doc.md>), [clang-tools-extra](<https://devfeed.tech/tags/clang-tools-extra.md>), [codegen](<https://devfeed.tech/tags/codegen.md>), [documentation](<https://devfeed.tech/tags/documentation.md>), [gsoc](<https://devfeed.tech/tags/gsoc.md>), [html](<https://devfeed.tech/tags/html.md>), [json](<https://devfeed.tech/tags/json.md>), [llvm](<https://devfeed.tech/tags/llvm.md>), [markdown](<https://devfeed.tech/tags/markdown.md>), [yaml](<https://devfeed.tech/tags/yaml.md>)

### AI overview

A GSoC 2025 contributor describes planned improvements to Clang-Doc, including broader C++ and Doxygen support and Markdown output. The article also explains Clang-Doc's map-reduce architecture and the difficulty of maintaining separate backend implementations for each output format.

### Source excerpt

I was selected as a contributor for GSoC 2025 under the project "Improving Core Clang-Doc Functionality" for LLVM.My mentors for the project were Paul Kirth and Petr Hosek. Clang-Doc is a tool in clang-tools-extra that generates documentation from Clang's AST and can output Markdown, HTML, YAML, and JSON.The project started in 2018 but major development eventually slowed.Recently, there have been efforts to get it back on track. This year, the GSoC project idea had a simple premise: improve core functionality. The Project The project idea proposed three main areas of focus to improve documentation quality. C++ support Doxygen comments Markdown support First, not all C++ constructs were supported, like friends or concepts.Not supporting core C++ constructs in C++ documentation is not good.Second, it's important that Doxygen command support is robust and that we can support as many as possible.Lastly, having Markdown available to developers for documentation would be useful.Markdown provides the power of expression in an area that is technically dense.It can be used to highlight critical information and warnings. The Architecture Here's a quick overview on Clang-Doc's architecture, which follows a map-reduce pattern: Visit source declarations via Clang's ASTVisitor. Serialize relevant source information into an Info (Clang-Doc's main data entity). Write Infos into bitcode, reduce, and reread. Serialize Infos into the desired format with a target backend. The architecture seems straightforward at a glance, but Clang-Doc has critical flaws at step 4. The Bad Clang-Doc has support for many formats.That sounds great in principal, but the backend pipeline's execution made development extremely cumbersome. Unlike in LLVM, Clang-Doc doesn't have a framework like CodeGen that shares functionality across different targets.To document a class, every backend needs to independently implement logic to serialize the class into its target format.Each backend also has separate logic

## GSoC 2025 - Byte Type: Supporting Raw Data Copies in the LLVM IR

DevFeed: [GSoC 2025 - Byte Type: Supporting Raw Data Copies in the LLVM IR](<https://devfeed.tech/articles/gsoc-2025-byte-type-supporting-raw-data-copies-in-the-llvm-ir-43117.md>)

Original publisher: [Read original article](<https://blog.llvm.org/posts/2025-08-29-gsoc-byte-type/>)

Author: Pedro Lobo

Published: 2025-09-08T00:00:00Z

Content type: article

Language: en

Sources: [LLVM Project](<https://devfeed.tech/sources/the-llvm-project-blog.md>)

Topics: [Compiler](<https://devfeed.tech/topics/compiler.md>), [LLVM](<https://devfeed.tech/topics/llvm.md>), [clang](<https://devfeed.tech/topics/clang.md>), [implementation](<https://devfeed.tech/topics/implementation.md>)

Tags: [2025](<https://devfeed.tech/tags/2025.md>), [bug](<https://devfeed.tech/tags/bug.md>), [clang](<https://devfeed.tech/tags/clang.md>), [compiler](<https://devfeed.tech/tags/compiler.md>), [gsoc](<https://devfeed.tech/tags/gsoc.md>), [implementation](<https://devfeed.tech/tags/implementation.md>), [intrinsics](<https://devfeed.tech/tags/intrinsics.md>), [ir](<https://devfeed.tech/tags/ir.md>), [llvm](<https://devfeed.tech/tags/llvm.md>), [llvm-ir](<https://devfeed.tech/tags/llvm-ir.md>), [memory](<https://devfeed.tech/tags/memory.md>), [optimizations](<https://devfeed.tech/tags/optimizations.md>), [pointers](<https://devfeed.tech/tags/pointers.md>), [provenance](<https://devfeed.tech/tags/provenance.md>), [raw](<https://devfeed.tech/tags/raw.md>), [type](<https://devfeed.tech/tags/type.md>)

### AI overview

An LLVM GSoC project adds a byte type to LLVM IR for representing raw memory values. The change supports native memory intrinsics, preserves pointer provenance and partially defined bits more accurately, addresses unsound transformations, and enables further optimizations.

### Source excerpt

This summer I participated in GSoC under the LLVM Compiler Infrastructure.The goal of the project was to add a new byte type to the LLVM IR, capable of representing raw memory values.This new addition enables the native implementation of memory-related intrinsics in the IR, including memcpy, memmove and memcmp, fixes existing unsound transformations and enables new optimizations, all with a minimal performance impact. Background One of LLVM's longstanding problems is the absence of a type capable of representing raw memory values.Currently, memory loads of raw bytes are performed through an appropriately sized integer type.However, integers are incapable of representing an arbitrary memory value.Firstly, they do not retain pointer provenance information, rendering them unable to fully specify the value of a pointer.Secondly, loading memory values containing poison bits through an integer type taints the loaded value, as integer values are either poison or have a fully-defined value, with no way to represent individual poison bits. Source languages such as C1 and C++2 provide proper types to inspect and manipulate raw memory.These include char, signed char and unsigned char.C++17 introduced the std::byte type, which offers similar raw memory access capabilities, but does not support arithmetic operations.Currently, Clang lowers these types to the i8 integer type, which does not accurately model their raw memory access semantics, motivating miscompilations such as the one reported in bug report 37469. The absence of a similar type in the LLVM IR hinders the implementation of memory-related intrinsics such as memcpy, memmove and memcmp, and introduces additional friction when loading and converting memory values to other types, leading to implicit conversions that are hard to identify and reason about.The two core problems stemming from the absence of a proper type to access and manipulate raw memory, directly addressed by the byte type and explored throughout the rema

## GSoC 2025: Profiling and Testing Math Functions on GPUs

DevFeed: [GSoC 2025: Profiling and Testing Math Functions on GPUs](<https://devfeed.tech/articles/gsoc-2025-profiling-and-testing-math-functions-on-gpus-43118.md>)

Original publisher: [Read original article](<https://blog.llvm.org/posts/2025-08-29-gsoc-profiling-and-testing-math-functions-on-gpus/>)

Author: Leandro Augusto Lacerda Campos

Published: 2025-09-01T00:00:00Z

Content type: article

Language: en

Sources: [LLVM Project](<https://devfeed.tech/sources/the-llvm-project-blog.md>)

Topics: [Computing](<https://devfeed.tech/topics/computing.md>), [GPU](<https://devfeed.tech/topics/gpu.md>), [Software Testing](<https://devfeed.tech/topics/software-testing.md>), [Benchmark](<https://devfeed.tech/topics/benchmark.md>), [LLVM](<https://devfeed.tech/topics/llvm.md>), [C](<https://devfeed.tech/topics/c.md>), [C++](<https://devfeed.tech/topics/c-plus-plus.md>), [OpenCL](<https://devfeed.tech/topics/opencl.md>), [Hardware](<https://devfeed.tech/topics/hardware.md>)

Tags: [2025](<https://devfeed.tech/tags/2025.md>), [benchmark](<https://devfeed.tech/tags/benchmark.md>), [benchmarking](<https://devfeed.tech/tags/benchmarking.md>), [c](<https://devfeed.tech/tags/c.md>), [c-plus-plus](<https://devfeed.tech/tags/c-plus-plus.md>), [code](<https://devfeed.tech/tags/code.md>), [computing](<https://devfeed.tech/tags/computing.md>), [cpu](<https://devfeed.tech/tags/cpu.md>), [data](<https://devfeed.tech/tags/data.md>), [gpu](<https://devfeed.tech/tags/gpu.md>), [gsoc](<https://devfeed.tech/tags/gsoc.md>), [hardware](<https://devfeed.tech/tags/hardware.md>), [implementation](<https://devfeed.tech/tags/implementation.md>), [infrastructure](<https://devfeed.tech/tags/infrastructure.md>), [libc](<https://devfeed.tech/tags/libc.md>), [libraries](<https://devfeed.tech/tags/libraries.md>), [library](<https://devfeed.tech/tags/library.md>), [llvm](<https://devfeed.tech/tags/llvm.md>), [math](<https://devfeed.tech/tags/math.md>), [opencl](<https://devfeed.tech/tags/opencl.md>), [profiling](<https://devfeed.tech/tags/profiling.md>), [testing](<https://devfeed.tech/tags/testing.md>)

### AI overview

This report describes a Google Summer of Code 2025 project that developed a C++ framework for conformance testing of GPU math functions in LLVM-libc and expanded benchmarking infrastructure. It covers standards compliance, accuracy measurement, performance comparisons with vendor libraries, and support for AMD and NVIDIA hardware.

### Source excerpt

With the increasing importance of GPU computing, having a robust and familiar C standard library becomes a valuable asset for developers. The LLVM project is actively working to provide this foundation, as a solid libc implementation enables more complex libraries to be developed for and used on GPUs. A key part of this effort is providing the C standard math library (LLVM-libm) on GPUs, often reusing the same target-agnostic implementations developed for CPU targets. This context creates a twofold challenge. First, there is a need to systematically verify the conformance of these implementations to standards like OpenCL. Second, it is crucial to benchmark their performance against the highly-optimized vendor libraries to understand the trade-offs involved. This Google Summer of Code 2025 project was designed to address both challenges by developing a framework for conformance testing as well as refining and expanding the existing benchmarking infrastructure. The work provides two benefits to the LLVM community: It empowers libc contributors with a robust tool to validate their GPU math function implementations. It builds trust with end-users by providing transparent accuracy and performance data. This report details the work completed on this project. Conformance Testing To address the goal of accuracy verification, I implemented a C++ framework for conformance testing within the offload/unittests/Conformance directory. This framework was designed to be extensible, easy to use, and capable of testing various implementation providers (llvm-libm, cuda-math, hip-math) across different hardware platforms (AMD, NVIDIA). Key Components The framework's power and simplicity come from a few key components that work together: DeviceContext: A lightweight wrapper around the new Offload API that abstracts away the low-level details of device discovery, resource management, and kernel launching. InputGenerator: An extensible interface for test input generation. The framework pr

## LLVMCGO25 - CARTS: Enabling Event-Driven Task and Data Block Compilation for Distributed HPC

DevFeed: [LLVMCGO25 - CARTS: Enabling Event-Driven Task and Data Block Compilation for Distributed HPC](<https://devfeed.tech/articles/llvmcgo25-carts-enabling-event-driven-task-and-data-block-compilation-for-distributed-hpc-43114.md>)

Original publisher: [Read original article](<https://blog.llvm.org/posts/2025-03-26-llvmcgo-carts/>)

Author: Rafael Andres Herrera Guaitero

Published: 2025-08-04T00:00:00Z

Content type: article

Language: en

Sources: [LLVM Project](<https://devfeed.tech/sources/the-llvm-project-blog.md>)

Topics: [High-Performance Computing](<https://devfeed.tech/topics/high-performance-computing.md>), [toolchain](<https://devfeed.tech/topics/toolchain.md>), [LLVM](<https://devfeed.tech/topics/llvm.md>), [mlir](<https://devfeed.tech/topics/mlir.md>), [distributed-systems](<https://devfeed.tech/topics/distributed-systems.md>), [event driven](<https://devfeed.tech/topics/event-driven.md>), [Concurrency](<https://devfeed.tech/topics/concurrency.md>), [data](<https://devfeed.tech/topics/data.md>), [Computing](<https://devfeed.tech/topics/computing.md>)

Tags: [arts](<https://devfeed.tech/tags/arts.md>), [compilation](<https://devfeed.tech/tags/compilation.md>), [computing](<https://devfeed.tech/tags/computing.md>), [concurrency](<https://devfeed.tech/tags/concurrency.md>), [data](<https://devfeed.tech/tags/data.md>), [distributed](<https://devfeed.tech/tags/distributed.md>), [event-driven](<https://devfeed.tech/tags/event-driven.md>), [hpc](<https://devfeed.tech/tags/hpc.md>), [llvm](<https://devfeed.tech/tags/llvm.md>), [mlir](<https://devfeed.tech/tags/mlir.md>), [software](<https://devfeed.tech/tags/software.md>)

### AI overview

A conference blog post introduces CARTS, a compiler framework for optimizing applications in distributed high-performance computing environments. It describes how CARTS combines MLIR and LLVM and explains ARTS, an event-driven runtime based on independent tasks and data dependencies.

### Source excerpt

LLVMCGO25 - CARTS: Enabling Event-Driven Task and Data Block Compilation for Distributed HPC Hello everyone! I'm Rafael, a PhD candidate at the University of Delaware. I recently flew from Philadelphia to Las Vegas to attend the CGO conference,where I had the chance to present my project and soak in new ideas about HPC. In this blog, I'll dive into the project I discussed at the conference and share some personal insights and lessons I learned along the way.Although comments aren't enabled here, I'd love to hear from you, feel free to reach out at (rafaelhg at udel dot edu) if you're interested in collaborating, have questions, or just want to chat. Motivation: Why CARTS? Modern High-Performance Computing (HPC) and AI/ML workloads are pushing our hardware and software to the limits. Some key challenges include: Evolving Architectures: Systems now have complex memory hierarchies that need smart utilization. Hardware Heterogeneity: With multi-core CPUs, GPUs, and specialized accelerators in the mix, resource management gets tricky. Performance Pressure: Large-scale systems demand efficient handling of concurrency, synchronization, and communication. These challenges led to the creation of CARTS--a compiler framework that combines the flexibility of MLIR with the reliability of LLVM to optimize applications for distributed HPC environments. A Closer Look at ARTS and Its Inspirations At the heart of CARTS is ARTS. Originally, ARTS stood for the Abstract Runtime System.I often get mixed up and mistakenly call it the Asynchronous Runtime System. To keep things light,we sometimes joke about it being the Any Runtime System. ARTS is inspired by the Codelet model, a concept I could talk about all day!The Codelet model breaks a computation into small, independent tasks (or "codelets") that can run as soon as their data dependencies are met.If you're curious to learn more about this model (or find it delightfully abstract), I suggest you visit our research group websiteat CAPSL,

## GSoC 2025: GPU-driven I/O with io\_uring

DevFeed: [GSoC 2025: GPU-driven I/O with io\_uring](<https://devfeed.tech/articles/gsoc-2025-gpu-driven-i-o-with-io-uring-43115.md>)

Original publisher: [Read original article](<https://blog.llvm.org/posts/2025-08-04-gpu-io-uring/>)

Author: Rodrigo Ceccato (rodrigo-ceccato)

Published: 2025-08-04T00:00:00Z

Content type: article

Language: en

Sources: [LLVM Project](<https://devfeed.tech/sources/the-llvm-project-blog.md>)

Topics: [GPU](<https://devfeed.tech/topics/gpu.md>), [io\_uring](<https://devfeed.tech/topics/io-uring.md>), [IO](<https://devfeed.tech/topics/io.md>), [Linux](<https://devfeed.tech/topics/linux.md>), [Code](<https://devfeed.tech/topics/code.md>), [implementation](<https://devfeed.tech/topics/implementation.md>), [Kernel](<https://devfeed.tech/topics/kernel.md>), [Remote Procedure Call (RPC)](<https://devfeed.tech/topics/rpc.md>), [Software Testing](<https://devfeed.tech/topics/software-testing.md>)

Tags: [asynchronous](<https://devfeed.tech/tags/asynchronous.md>), [code](<https://devfeed.tech/tags/code.md>), [gpu](<https://devfeed.tech/tags/gpu.md>), [gsoc](<https://devfeed.tech/tags/gsoc.md>), [implementation](<https://devfeed.tech/tags/implementation.md>), [io](<https://devfeed.tech/tags/io.md>), [io-uring](<https://devfeed.tech/tags/io-uring.md>), [kernel](<https://devfeed.tech/tags/kernel.md>), [linux](<https://devfeed.tech/tags/linux.md>), [llvm](<https://devfeed.tech/tags/llvm.md>), [pcie](<https://devfeed.tech/tags/pcie.md>), [rpc](<https://devfeed.tech/tags/rpc.md>), [testing](<https://devfeed.tech/tags/testing.md>)

### AI overview

A GSoC 2025 project explores GPU-initiated I/O by allowing GPU code to write directly to an io_uring submission queue backed by shared virtual memory. The prototype implements a printf-like interface and tests synchronous and kernel-level polling modes.

### Source excerpt

Hello everyone! My name is Rodrigo Ceccato, and for GSoC 2025 I've been working on GPU-driven I/O using io_uring. This 8-week project focuses on developing a prototype of a printf-like interface for the GPU, backed by Shared Virtual Memory (SVM) to directly access the io_uring submission queue. Background LLVM libc for GPUs implements libc functions that run natively on GPUs (e.g. math and printf routines). However, some operations rely on system calls, like printf(), which is done via a remote procedure call (RPC) to the CPU, like the image below shows. This approach uses a mailbox that is read by a user-level polling thread and transfer data through a shared buffer. This current implementation saturates at around 15MB/s, well below the PCIe bus speed. Our project explores io_uring to allow GPU-initiated I/O. io_uring is a Linux feature that lets the user register a submission queue for asynchronous and batched I/O operations. As the image below shows, we explore the concept of using a SVM region for the submission queue, and pass it to the GPU using a helper function that handles the print operation. What We Did We built a prototype that allows the GPU to deliver a print message using io_uring, eliminating the need to hop through a shared mailbox and a user-level polling thread. Instead, the GPU writes directly into the io_uring submission queue, which is backed by fine-grained SVM memory allocated through the HSA API. We validated the feasibility of this setup by testing whether SVM pointers could be safely passed to io_uring, and confirmed that the kernel polling thread could process submissions written entirely from GPU code. A simple print function was implemented to format messages on the device and enqueue them to the ring. We tested the system in two modes: using synchronous io_uring flushes where the CPU manually checked completions, and using kernel-level polling where no active host thread is needed. These tests confirmed not only that the GPU could issu

## LLVM Fortran Levels Up: Goodbye flang-new, Hello flang!

DevFeed: [LLVM Fortran Levels Up: Goodbye flang-new, Hello flang!](<https://devfeed.tech/articles/llvm-fortran-levels-up-goodbye-flang-new-hello-flang-43113.md>)

Original publisher: [Read original article](<https://blog.llvm.org/posts/2025-03-11-flang-new/>)

Author: David Spickett

Published: 2025-03-11T00:00:00Z

Content type: article

Language: en

Sources: [LLVM Project](<https://devfeed.tech/sources/the-llvm-project-blog.md>)

Topics: [Fortran](<https://devfeed.tech/topics/fortran.md>), [Compiler](<https://devfeed.tech/topics/compiler.md>), [LLVM](<https://devfeed.tech/topics/llvm.md>), [mlir](<https://devfeed.tech/topics/mlir.md>), [High-Performance Computing](<https://devfeed.tech/topics/high-performance-computing.md>), [Computing](<https://devfeed.tech/topics/computing.md>)

Tags: [assembly](<https://devfeed.tech/tags/assembly.md>), [compiler](<https://devfeed.tech/tags/compiler.md>), [compilers](<https://devfeed.tech/tags/compilers.md>), [computing](<https://devfeed.tech/tags/computing.md>), [flang](<https://devfeed.tech/tags/flang.md>), [high-performance-computing](<https://devfeed.tech/tags/high-performance-computing.md>), [llvm](<https://devfeed.tech/tags/llvm.md>), [mlir](<https://devfeed.tech/tags/mlir.md>), [open-source](<https://devfeed.tech/tags/open-source.md>)

### AI overview

This article describes Flang, LLVM's Fortran compiler, including its transition from flang-new to flang in LLVM 20. It reviews the compiler's development, adoption of MLIR, history, and role in high-performance and scientific computing.

### Source excerpt

LLVM has included a Fortran compiler "Flang" since LLVM 11 in late 2020. However,until recently the Flang binary was not flang (like clang) but insteadflang-new. LLVM 20 ends the era of flang-new. The community has decided that Flang isworthy of a new name. The "new" name? You guessed it, flang. A simple change that represents a major milestone for Flang. This article will cover the almost 10 year journey of Flang. The firstconcepts, multiple rewrites, the adoption of LLVM's Multi Level IntermediateRepresentation (MLIR) and Flang entering the LLVM Project. If you want to try flang right now, you candownloadit or try it in your browser usingCompiler Explorer. Why Fortran? Fortran was first created in the 1950s, and the name came from "Formula Translation".Fortran focused on the mathematics use case and freed programmers from writingassembly code that could only run on specific machines. Instead they could write code that looked like a formula. You expect this todaybut for the time it was a revolution. This feature led to heavy use in scientificcomputing: weather modelling, fluid dynamics and computational chemistry, justto name a few. Whilst many alternative programming languages have comeand gone, it [Fortran] has regained its popularity for writing highperformance codes. Indeed, over 80% of the applicationsrunning on ARCHER2, a 750,000 core Cray EX which isthe UK national supercomputer, are written in Fortran. Fortran High-Level Synthesis: Reducing the barriersto accelerating High Performance Computing (HPC) codes on FPGAs (Gabriel Rodriguez-Canal et al., 2023) Fortran has had a resurgencein recent years, gaining a package manager, an unofficialstandard library and LFortran,a compiler that supports interactive programming (LFortran also uses LLVM). For the full history of Fortran, IBM has an excellent articleon the topic and I encourage you to look at the"Programmer's Primer for Fortran"if you want to see the early form of Fortran. If you want to learn the language

## GSoC 2024: Improve Clang Doc

DevFeed: [GSoC 2024: Improve Clang Doc](<https://devfeed.tech/articles/gsoc-2024-improve-clang-doc-43112.md>)

Original publisher: [Read original article](<https://blog.llvm.org/posts/2024-12-04-improve-clang-doc/>)

Author: Peter Chou

Published: 2024-12-23T00:00:00Z

Content type: article

Language: en

Sources: [LLVM Project](<https://devfeed.tech/sources/the-llvm-project-blog.md>)

Topics: [Documentation](<https://devfeed.tech/topics/documentation.md>), [LibTooling](<https://devfeed.tech/topics/libtooling.md>), [software-development](<https://devfeed.tech/topics/software-development.md>), [Tool](<https://devfeed.tech/topics/tool.md>), [Software Testing](<https://devfeed.tech/topics/software-testing.md>), [LLVM](<https://devfeed.tech/topics/llvm.md>), [C++](<https://devfeed.tech/topics/c-plus-plus.md>)

Tags: [c-plus-plus](<https://devfeed.tech/tags/c-plus-plus.md>), [clang](<https://devfeed.tech/tags/clang.md>), [clang-doc](<https://devfeed.tech/tags/clang-doc.md>), [gsoc](<https://devfeed.tech/tags/gsoc.md>), [libtooling](<https://devfeed.tech/tags/libtooling.md>), [llvm](<https://devfeed.tech/tags/llvm.md>), [make](<https://devfeed.tech/tags/make.md>), [markdown](<https://devfeed.tech/tags/markdown.md>), [testing](<https://devfeed.tech/tags/testing.md>)

### AI overview

A Google Summer of Code 2024 project improved Clang-Doc, an LLVM libTooling-based documentation generator. The work addressed usability issues in generated HTML, added support for more C++ constructs, expanded end-to-end tests, and improved performance after identifying excessive runtime, memory use, and crashes on large codebases.

### Source excerpt

Hi, my name is Peter, and this year I was involved in Google Summer of Code 2024. I worked on improving the Clang-Doc documenation generator Mentors: Petr Hosek and Paul Kirth Project Background Clang-Doc is a documentation generator developed on top of libtooling, as analternative to Doxygen. Development started in 2018 and continued through 2019,however, it has since stalled. Currently, the tool can generate HTML, YAML, and markdown but the generated output has usability issues. This GSOC project aimed to address the pain points regarding the output of the HTML, by adding support for various C++ constructs and reworking the CSS of the HTML output to be more user-friendly. Work Done The original scope of the project was to improve the output of Clang-Doc's generation. However during testing the tool was significantly slower than expected which made developing features for the tool impossible.Documentation generation for the LLVM codebase was taking upwards of 10 hours on my local machine. Additionally, the tool utilized a lot of memory and was prone to crashing with an out-of-memory error. Similar tools such as Doxygen and Hdoc ran in comparatively less time for the same codebase. This pointed to a significant bottleneck within Clang-Doc's code path when generating large-scale software projects. Due to this the project scope quickly changed to improving the runtime of Clang-Doc so that it could run much faster. It was only during the latter half of the project did the scope changed back to improving Clang-Doc's generation. Added More Test Cases to Clang-Doc test suite Clang-Doc previously had tests which did not test the full scope of the the HTML or Markdown output. I added more end-to-end tests to make sure that in the process of optimizing documentation generation we were not degrading the quality or functionality of the tool. In summary, I added four comprehensive tests that covered all features that we were not testing such as testing the generation for Enums,

[Next page](<https://devfeed.tech/sources/the-llvm-project-blog.md?cursor=WyIyMDI0LTEyLTIzVDAwOjAwOjAwKzAwOjAwIiwgIjFjNmZkZjQ1LTE5YTQtNGZiOC05MmNmLTljNjM4ZmIzOWExOSJd>)