[qt/clang/llvm]: Summary of bulk changes made

Git repository change summary for qt/clang/llvm
Pushed by mirror-service into branch 'upstream/main'.
Changed from 136547ce3f53d8835c20fbdbc602f899ac8a069d to d53ebd23aabd9286075650b663ff0bcbbef9ebd8
Acknowledgement was received that this change introduces only existing code that has been pushed to another public open source repository.

This change contains the following new commits:

Git commit f8e258866980da486756e241016dd33ae68450be by GitHub (on behalf of Louis Dionne) on 21/07/2026 at 11:21..
[libc++] Include sizes in string benchmark names (#210795)

Otherwise we'd have duplicate benchmark names.
https://invent.kde.org/qt/clang/llvm/-/commit/f8e258866980da486756e241016dd33ae68450be

Git commit 7f49d95c09e8a22a6de737ae6006edbb3a0adfca by GitHub (on behalf of Louis Dionne) on 21/07/2026 at 11:22..
[libc++][NFC] Fix synopsis comment for error_condition::message() (#210724)

The method was marked as noexcept in the synopsis, but it's neither
marked noexcept in the spec nor in our implementation.
https://invent.kde.org/qt/clang/llvm/-/commit/7f49d95c09e8a22a6de737ae6006edbb3a0adfca

Git commit df4bb1f3106d39e5c6b767a28c0531efbbebc2d2 by GitHub (on behalf of Louis Dionne) on 21/07/2026 at 11:23..
[libc++] Compose the test suite Lit site config from harness and installation substitutions (#209638)

This patch restructures how libc++'s Lit site config is generated.
Instead of relying on the user-selected configuration file to include
the CMake bridge, it composes a site configuration from multiple
independent bits.

Importantly, it splits substitutions that pertain to the harness setup
(e.g. where to find Python) and substitutions that pertain to libc++
itself (e.g. the path to libc++ headers). This split and the top-level
composition of a site config file are incremental steps towards
decoupling the test suite from libc++'s own build.
https://invent.kde.org/qt/clang/llvm/-/commit/df4bb1f3106d39e5c6b767a28c0531efbbebc2d2

Git commit ad3f09c7de3da1f023bc1134eaa33be6d39cc9ca by GitHub (on behalf of Gábor Horváth) on 21/07/2026 at 11:33..
[ADT] Add single-pass merge for ImmutableSet/ImmutableMap (#209807)

The immutable-set/map dataflow joins merged two containers by inserting
the
elements of one into the other one at a time, costing O(|B| * log|A|)
and
re-copying shared spine nodes on every insert.

Add a single-pass, structure-sharing tree merge on ImutAVLFactory
(mergeTrees), exposed as ImmutableSet::Factory::unionSets and
ImmutableMap::Factory::mergeWith. It recurses over the larger operand
and
splits the smaller at each key, returning non-overlapping subtrees
unchanged,
so each spine node is copied at most once: O(|B| * log(|A|/|B| + 1)).

Two flags tune it for the different joins:
* KeepUnmatched - keep keys unique to one side (set union / a lattice
join
with an identity) vs. pass them through the combiner (a symmetric join,
   e.g. liveness Must->Maybe).
* SkipShared - return a pointer-identical subtree unchanged in O(1).
Valid
for an idempotent merge (Combine(a, a) == a), which holds for set union
and
every lattice join. Since dataflow states are path-copied from one
another,
a join's operands usually share most subtrees by pointer, so a join that
   touches only a few keys becomes nearly O(diff).

Wire it into the Clang lifetime-safety analysis (set and map joins) and
the
LiveVariables merge, and add ImmutableMergeBM to track it.

Speedups on the lifetime-safety dataflow benchmark (LoanPropagation
phase):
      pointer cycle in a loop  ~2.6x   (1.59 s  -> 0.61 s)
      CFG merges               ~190x   (1.83 s  -> 9.5 ms)
switch fan-out ~1.9x (LiveOrigins; disjoint states, no skip)
LiveVariables is ~2-3x faster on liveness-heavy inputs and neutral on
typical
code (the join is a small fraction of real-code analysis time).

ImmutableMergeBM confirms the merge beats the add loop for small and
near-identical operands, except for independently-built sets differing
by
exactly one element; when one operand is derived from the other -- the
real
dataflow case -- the pointer-skip makes even that a large win. New
randomized
ADT stress tests check the merge against std::set/std::map oracles for
both
canonicalizing and non-canonicalizing factories.

Assisted by: Claude Opus 4.8

Co-authored-by: Gabor Horvath <[email protected]>
https://invent.kde.org/qt/clang/llvm/-/commit/ad3f09c7de3da1f023bc1134eaa33be6d39cc9ca

Git commit b8eebf2704f2ebb6894fd952e4f15fdb62270606 by GitHub (on behalf of h-vetinari) on 21/07/2026 at 11:34..
[libc++][NFC] Re-order availability mapping to `_LIBCPP_INTRODUCED_IN_LLVM_{N}` (#210694)

Noticed that the new additions (from 16f692338cf and 8a531c3608c) were placed
rather randomly. Put the mapping back to reverse chronological order, see 
783fd2f9d.
https://invent.kde.org/qt/clang/llvm/-/commit/b8eebf2704f2ebb6894fd952e4f15fdb62270606

Git commit c40a68644c550dcfa3c3d0b560e3aeea1d159d79 by GitHub (on behalf of Michael G. Kazakov) on 21/07/2026 at 11:40..
[libc++] Strip cv-refs in __desugars_to specialization for integral types (#208950)

This PR passes the argument type through `__remove_cvref_t` before
passing to `is_integral`.

Fixes #208236
https://invent.kde.org/qt/clang/llvm/-/commit/c40a68644c550dcfa3c3d0b560e3aeea1d159d79

Git commit faaeaf35a50acefd4e25e092e3f720067c40afe3 by GitHub (on behalf of Connector Switch) on 21/07/2026 at 11:41..
[libc++] Implement P0493R5: Atomic minimum/maximum (#180333)

Closes #105418.

Since gcc does not currently support `__atomic_fetch_min/max`, we use a
CAS loop in `atomic_ref` and `support/gcc.h`.

---------

Co-authored-by: Louis Dionne <[email protected]>
https://invent.kde.org/qt/clang/llvm/-/commit/faaeaf35a50acefd4e25e092e3f720067c40afe3

Git commit 460778b9d64ed36fd7e80a4cc73ea552aebf016b by GitHub (on behalf of Michael G. Kazakov) on 21/07/2026 at 11:42..
[libc++][pstl] Default implementation of parallel std::adjacent_difference (#207585)

This PR adds a "one-liner" default implementation of parallel
`std::adjacent_difference` on top of parallel binary `std::transform`.

The implementation builds two iterator ranges out of the input one, so
that a zip of these ranges yields adjacent pairs. Then performs a binary
transform to calculate and output the adjacent differences.

Part of https://github.com/llvm/llvm-project/issues/99938
https://invent.kde.org/qt/clang/llvm/-/commit/460778b9d64ed36fd7e80a4cc73ea552aebf016b

Git commit d7da964ee1eab426e0d1f617ae2947f4e30d304f by GitHub (on behalf of Balázs Benics) on 21/07/2026 at 11:46..
[analyzer][NFC] Add StackFrame parent-chain range helpers (#210938)

Walking a StackFrame's parent chain was open-coded across the Analysis
library and Static Analyzer as hand-rolled loops of the form `for (const
StackFrame *SF = X; SF; SF = SF->getParent())`.

Add range-based traversal helpers and convert the applicable loops:

* StackFrame::parents() - strict ancestors (excludes *this)
* StackFrame::parentsIncludingSelf() - *this then all ancestors

Both are built on a small forward `parent_iterator` that dereferences to
`const StackFrame &` and advances via getParent(), with a null
past-the-end sentinel.

For the common case of obtaining the current frame from an ExplodedNode
or CheckerContext, add a self-inclusive `stackframes()` convenience on
each that delegates to `getStackFrame()->parentsIncludingSelf()`.

Converted call-sites additionally adopt llvm::any_of / llvm::enumerate /
make_pointer_range where it makes the traversal more declarative. Loops
that stop at a target frame or advance conditionally (i.e. not "walk
until null") are intentionally left as-is.
https://invent.kde.org/qt/clang/llvm/-/commit/d7da964ee1eab426e0d1f617ae2947f4e30d304f

Git commit f72f994ad894bf82ab8d12f848f583c5d0cf0048 by GitHub (on behalf of Luke Hutton) on 21/07/2026 at 11:46..
[mlir][ods] Fix string interpolation at end of description (#209744)

Updates the error streaming string logic to handle the case where string
interpolation used at the end of the description. Previously this could
generate malformed code that would not compile e.g.:
```
"' failed to satisfy constraint: another attribute " << reformat(attr)";
```
With this change the above example would now generate:
```
"' failed to satisfy constraint: another attribute " << reformat(attr) << "";
```
https://invent.kde.org/qt/clang/llvm/-/commit/f72f994ad894bf82ab8d12f848f583c5d0cf0048

Git commit 3fc3ef399d9972361209917bf26ae9cc7317d3a9 by GitHub (on behalf of Akshay K) on 21/07/2026 at 11:47..
[Clang] Fix assertion failure when classifying a dependent call to a builtin (#210524)

## Summary
Fix an assertion failure when Clang classifies a built-in call with
type-dependent arguments before template instantiation, e.g., while
deducing an `auto` non-type template parameter:

  For example:
  ```cpp
  template <auto> struct S {};

  template <typename T>
  using Alias = S<__builtin_constant_p(T::x)>;
```
```
Assertion failed: (isa<T>(CanonicalType)), function castAs, file
TypeBase.h, line 9349.
 #9  clang::Type::castAs<clang::FunctionType>() const
 #10 clang::CallExpr::getCallReturnType(clang::ASTContext const&) const
 #11 ClassifyInternal(clang::ASTContext&, clang::Expr const*)
#12 clang::Expr::ClassifyImpl(clang::ASTContext&,
clang::SourceLocation*) const
 #13 clang::Sema::DeduceAutoType(...)
 #14 clang::Sema::CheckTemplateArgument(...)
```

## Cause
Built-in references initially have the BuiltinFn placeholder type. For a non-dependent call, `BuildResolvedCallExpr()` applies `CK_BuiltinFnToFnPtr`, converting the callee to its function-pointer type. 

When a call has type-dependent arguments, `BuildCallExpr()` postpones semantic analysis until instantiation. The callee, therefore, retains its BuiltinFn placeholder type. Deducing the auto non-type template parameter classifies the dependent call through `Expr::ClassifyImpl()`. This calls `CallExpr::getCallReturnType()`, which previously did not handle BuiltinFn and attempted to cast the placeholder to FunctionType, triggering an assertion.

The issue also affects ordinary builtins such as `__builtin_ffs` and is not specific to` __builtin_constant_p`.

 ## Fix
Handle `BuiltinFn` alongside the dependent and `Overload` callee cases in `CallExpr::getCallReturnType()` and return `DependentTy`. This matches the type `BuildCallExpr()` gives the `CallExpr` itself, so `getCallReturnType()` and `getType()` now agree on such calls.

Built-in resolution and built-in-specific type checking still occur as usual during template instantiation.

Added coverage for dependent calls and successful instantiation of `__builtin_constant_p` and `__builtin_ffs`,  a non-dependent control case, and getCallReturnType() for a BuiltinFn callee.
https://invent.kde.org/qt/clang/llvm/-/commit/3fc3ef399d9972361209917bf26ae9cc7317d3a9

Git commit fe0bc1136dc991486e6a84d6ed034dc3617faaa7 by GitHub (on behalf of Mariusz Sikora) on 21/07/2026 at 12:09..
[NFC][AMDGPU] Add s_wait asynccnt/tensorcnt test for gfx13 (#210916)
https://invent.kde.org/qt/clang/llvm/-/commit/fe0bc1136dc991486e6a84d6ed034dc3617faaa7

Git commit f2153eec7aaddd227c303bf0b6e6a8ccb7863857 by GitHub (on behalf of Alexis Engelke) on 21/07/2026 at 12:14..
[Xtensa][NFC] Use compact enum for CPUNames/features (#206954)

Store strings without relocations using compact enums. This reduces the
size of libLLVM.so .data.rel.ro by ~1kiB.
https://invent.kde.org/qt/clang/llvm/-/commit/f2153eec7aaddd227c303bf0b6e6a8ccb7863857

Git commit 4d4bf128eb54cdd2ad347507208a202da1f9c172 by GitHub (on behalf of Arseniy Obolenskiy) on 21/07/2026 at 12:29..
[AMDGPU] Reject illegal buffer atomic data widths in SelectionDAG (#210925)

Continuation of the fix introduced in #210366, but this time for
raw/struct buffer atomics instead of image atomics
https://invent.kde.org/qt/clang/llvm/-/commit/4d4bf128eb54cdd2ad347507208a202da1f9c172

Git commit a83cc57559428ebd51d51c83db27a9454fbbe114 by GitHub (on behalf of eleviant) on 21/07/2026 at 12:31..
Attempt to fix buildbot failure (#210956)

Value names are discarded by default on build without asserts.
https://invent.kde.org/qt/clang/llvm/-/commit/a83cc57559428ebd51d51c83db27a9454fbbe114

Git commit 981735b4df68cab22c5c8309f4fbc6b26aab7258 by GitHub (on behalf of Alexey Bataev) on 21/07/2026 at 12:32..
[SLP]Fix crash on short interleaved gathered-load remainder

A trailing, undersized chunk could keep an InterleaveFactor too
large for it, so RISCVTTIImpl::getInterleavedMemoryOpCost divided
by it and built a zero-element vector type.

Fixes #210849

Reviewers: 

Pull Request: https://github.com/llvm/llvm-project/pull/210965
https://invent.kde.org/qt/clang/llvm/-/commit/981735b4df68cab22c5c8309f4fbc6b26aab7258

Git commit 3ed183660093a3d6aa286b5d1339a19c0c834aa1 by GitHub (on behalf of Ömer Sinan Ağacan) on 21/07/2026 at 12:33..
[GlobalISel][AArch64] Add more memcpy and memmove tests (NFC) (#210263)

Test inlined memcpy and memmove operations with multiple loads/stores
with different sizes.

New IR tests added for size 7 to check which one of load/store sequences
we generate:

- 4 + 2 + 1 bytes
- 4 + 4 bytes (4 bytes at offset, 4 bytes at offset + 3)

We also didn't have the `memcpy_inline_...` tests for the
`memmove.inline` intrinsic. I've copied all `memcpy_inline_...` tests
for `memmove.inline`, with the exception of sizes 65, 64, and 63, as I'm
not sure whether they're useful. (the same edge cases are already
checked in tests with sizes 10 and 7)

List of all IR tests added:

- memcpy_7
- memcpy_7_volatile
- memcpy_inline_7
- memcpy_inline_7_volatile
- memmove_7
- memmove_7_volatile
- memmove_inline_0
- memmove_inline_0_volatile
- memmove_inline_7
- memmove_inline_7_volatile
- memmove_inline_10
- memmove_inline_10_volatile
- memmove_inline_300
- memmove_inline_300_volatile
https://invent.kde.org/qt/clang/llvm/-/commit/3ed183660093a3d6aa286b5d1339a19c0c834aa1

Git commit 1a11f6ca17790ced1f3108c290e9c48d9bdb55e3 by GitHub (on behalf of Felipe de Azevedo Piovezan) on 21/07/2026 at 12:33..
[lldb] Delete AppleObjCRuntimeV1 (#203190)

This was used in older 32-bit ObjC programs, and it is not used anywhere
by the debugger.
https://invent.kde.org/qt/clang/llvm/-/commit/1a11f6ca17790ced1f3108c290e9c48d9bdb55e3

Git commit 27eeb7370281e4fdefdddeaa4b3cbb8ca11ea71f by GitHub (on behalf of Matt Arsenault) on 21/07/2026 at 12:38..
AMDGPU: Use module flags to control xnack and sramecc (#204595)

This ensures these ABI details are encoded in the IR module
rather than depending on external state from command-line flags.
Previously, these were encoded as function-level subtarget features.
The code object output was a single target ID directive implied
by the global subtarget. The backend would previously check if a
function's subtarget feature mismatched the global subtarget. This
is avoided by making xnack and sramecc module-level properties from
the start. This also provides proper linker compatibility
enforcement, moving the error point earlier.

The old encoding was also an abuse of the subtarget feature system.
Subtarget features are a bitvector, and later features in the string
can override earlier ones. The old handling added a special case
where explicit settings were preserved: ordinarily +feature,-feature
should result in the feature being disabled, but +xnack,-xnack would
preserve the explicit "-xnack" state, which differs from the absence
of any xnack setting.

The new flags are encoded as 0/1, with the "any" case represented
as the absence of the flag. I considered an explicit tri-state unknown
value, but decided against it.

This also removes warnings when using these module flags on targets
that do not support the corresponding feature. Previously, messages
were written directly to stderr instead of using proper diagnostics.
Avoiding the warning reduces burden on frontends to check which targets
require the flags.

For migration purposes, the subtarget features still exist. Currently,
they are still respected in the various binary tools, pending
disassembler changes to determine target ID modifiers from e_flags.
CodeGen requires using the module flags. An error will be raised when
attempting to use the old global subtarget features. These should be
removed after a migration period for frontends to update. Functionality
wise, bitcode autoupgrade should work. Old bitcode will not have the
flags, resulting in a different target ID in the output binary than
expected, but it should run correctly.

New cl::opts exist only because it was inconvenient to update all
tests using multiple xnack modes. Users should never use these.

Co-Authored-By: Claude Opus 4.6 <[email protected]>
https://invent.kde.org/qt/clang/llvm/-/commit/27eeb7370281e4fdefdddeaa4b3cbb8ca11ea71f

Git commit f90e121dde60bea7e2988cf277ca4a484bce33b9 by GitHub (on behalf of Paulius Velesko) on 21/07/2026 at 12:39..
[Darwin] Use macOS product version in ensureTargetInitialized (#206902)

`Darwin::ensureTargetInitialized()` recorded the raw triple OS version
from `getOSVersion()`, which on macOS is the Darwin *kernel* version
(e.g. `24.3.0`), not the macOS *product* version (`15.x`). The offload
host job later calls `setTarget()` again from `AddDeploymentTarget()`
with the product version; `setTarget()`'s reinit guard only
short-circuits when the versions match, so the mismatch trips
`assert(!TargetInitialized && "Target already initialized!")` and clang
aborts on every `-x hip --offload=spirv64* --target=arm64-apple-darwin`
compile.

Convert macOS kernel versions via `getMacOSXVersion()` so the lazy init
records the same version `AddDeploymentTarget()` uses later.
https://invent.kde.org/qt/clang/llvm/-/commit/f90e121dde60bea7e2988cf277ca4a484bce33b9

Git commit b1d21c6d3121898dc13c0df8cf9e4410bee75cfb by GitHub (on behalf of Paulius Velesko) on 21/07/2026 at 12:39..
[ExpandVariadics] Don't lower unmangled C printf on SPIR-V (#206998)

An unmangled C `printf` declaration demangles to bare `printf` (no
argument list), so `SPIRV::ignoreFunction`'s `printf(` prefix check
missed it and ExpandVariadics packed its arguments into a vararg buffer;
the SPIR-V backend then passed the buffer pointer as printf's first
variadic operand, so device printf printed pointer values instead of the
actual arguments. Match the bare name too so OpenCL/HIP printf (emitted
unmangled) is left as a variadic call for the backend's OpenCL.std
printf lowering.
https://invent.kde.org/qt/clang/llvm/-/commit/b1d21c6d3121898dc13c0df8cf9e4410bee75cfb

Git commit 4aa8d561bb06ecf89c723524fddbf0b58c5ec205 by GitHub (on behalf of Paul Walker) on 21/07/2026 at 12:49..
[LLVM][SVE] Convert FFR intrinsic definition to use IntrRead/IntrWrite. (#210084)

Follows on from https://github.com/llvm/llvm-project/issues/154144 to
better articulate the FFR intrinsics memory effects.

I've been deliberatly cautious with marking FFR as read/write for the
load intrinsics. There is an argument they could be write only but I'm
not looking to optimise FFR accesses at this stage.
https://invent.kde.org/qt/clang/llvm/-/commit/4aa8d561bb06ecf89c723524fddbf0b58c5ec205

Git commit 42972f5e5d950b6644a926f402dc54ea3ff06ec3 by GitHub (on behalf of Erich Keane) on 21/07/2026 at 12:56..
[CIR] Introduce data_member_offset attribute (#208777)

Some fields, like no_unique_address marked ones, aren't present in the
CIR struct type. This attribute represents an offset into a struct
instead, since get_member isn't possible without a member.

I also considered representing these types in the struct, but it ends up
causing a lot of awful looking structs, and forces the LLVMIR to contain
empty fields for each of these, but not in lexical order, which is
particularly awful looking.

I considered making this part of data-member, but it seems like not a
particularly good idea, since this isn't really getting a 'member' in
the traditional sense.
https://invent.kde.org/qt/clang/llvm/-/commit/42972f5e5d950b6644a926f402dc54ea3ff06ec3

Git commit 0e678e9ef18b1b2d3261207e288ae3f2667bbd19 by GitHub (on behalf of Nico Weber) on 21/07/2026 at 12:59..
[gn build] Port ea205541b987 (#210977)
https://invent.kde.org/qt/clang/llvm/-/commit/0e678e9ef18b1b2d3261207e288ae3f2667bbd19

Git commit 11a6145c5ed1f9676ad18189b7071e456c76bb79 by GitHub (on behalf of Nico Weber) on 21/07/2026 at 12:59..
[gn build] Port 921f4da4a05f (#210976)
https://invent.kde.org/qt/clang/llvm/-/commit/11a6145c5ed1f9676ad18189b7071e456c76bb79

Git commit 114372a86e7463cbdb52ced9f73cc7d70f49eda9 by GitHub (on behalf of Nico Weber) on 21/07/2026 at 12:59..
[gn build] Port 30c0454414ec (#210975)
https://invent.kde.org/qt/clang/llvm/-/commit/114372a86e7463cbdb52ced9f73cc7d70f49eda9

Git commit 14cb4614c65acc3c4f454220c2f2dae7b5ddaf34 by GitHub (on behalf of Nico Weber) on 21/07/2026 at 13:00..
[gn build] Port 1a11f6ca1779 (#210974)
https://invent.kde.org/qt/clang/llvm/-/commit/14cb4614c65acc3c4f454220c2f2dae7b5ddaf34

Git commit 2cd5deb2208683bc2d3545e125258a9714f3aef1 by GitHub (on behalf of Louis Dionne) on 21/07/2026 at 13:03..
[libc++] Fix test-at-commit after df4bb1f3106d (#210983)
https://invent.kde.org/qt/clang/llvm/-/commit/2cd5deb2208683bc2d3545e125258a9714f3aef1

Git commit 1d0b606198b502a307da0f688262a1044c38f316 by GitHub (on behalf of Dan Blackwell) on 21/07/2026 at 13:08..
[Darwin][TSan] Fix race in mach_vm_deallocate interceptor (#210716)

I have seen an issue whereby the meta store in MetaMap::AllocBlock lands
in the unmapped gap left during the tsan::MetaMap::ResetRange call;
where the range is first unmapped, and then remapped with MAP_FIXED.
This occurred under the mach_vm_deallocate interceptor, because it first
does the deallocate call, and only then does it call UnmapShadow -
leaving a gap where a fresh slab for malloc can land, only to have the
meta region for that range mapped out from under it, resulting in a bad
access fault.

It is worth noting that there is a comment above the IsValidMmapRange
function (which gets called during UnmapShadow), that describes this
exact issue in the context of munmap.

rdar://179172055

Assisted by: Claude
https://invent.kde.org/qt/clang/llvm/-/commit/1d0b606198b502a307da0f688262a1044c38f316

Git commit 215b3e42d03e7e0cbd49ae0b15e726b3d1bdc360 by GitHub (on behalf of Michał Kurek) on 21/07/2026 at 13:18..
[DAGCombiner] Teach MatchLoadCombine to look through AND masks (#200247)

Fixes #191193

`MatchLoadCombine` can combine OR trees built from shifted/zexted
consecutive byte loads into a wider load, but it currently bails out
when one of the loaded bytes is masked before being shifted into place.
This will miss patterns such as the following
```
  zext(load i8 p) | (zext(and(load i8 p+1, 3)) << 8)
```
which can be implemented as a 16-bit load followed by a mask.

This PR teaches `calculateByteProvider()` to look through constant AND
masks by tracking the mask applied to each byte. When the byte providers
cover a consecutive load range, we form the wider load and apply a final
mask to preserve the original value.

Added X86 and AArch64 tests covering the masked-byte combine, plus
negative cases (non-adjacent loads, volatile, variable mask, multi-use
AND).

Assisted-by: Claude Code
https://invent.kde.org/qt/clang/llvm/-/commit/215b3e42d03e7e0cbd49ae0b15e726b3d1bdc360

Git commit 81081c00e99e35394e4d09016e565443cbec254e by GitHub (on behalf of Momchil Velikov) on 21/07/2026 at 13:19..
[GVN] Remove unused debug helper (NFC) (#210333)

The `GVNPass::dump` method is not used anywhere. Moreover, there's no
`GVNPass` state that corresponds to its parameter type. Even if a
`GVNPass::dump` method could be useful, this one wasn't it.
https://invent.kde.org/qt/clang/llvm/-/commit/81081c00e99e35394e4d09016e565443cbec254e

Git commit 7c445ab1d08597a89a829ff938b55264cc480150 by GitHub (on behalf of Zorojuro) on 21/07/2026 at 13:20..
[libc] Float128 Emulation in LLVM libc (#200565)

Introducing emulated float128 in LLVM libc
https://invent.kde.org/qt/clang/llvm/-/commit/7c445ab1d08597a89a829ff938b55264cc480150

Git commit 7c40a1d796cec2207bc697d94355a71962ee33df by GitHub (on behalf of Simon Pilgrim) on 21/07/2026 at 13:26..
[CostModel][X86] getArithmeticReductionCost - convert to CostKindTblEntry entries. NFC. (#210969)

No actual cost changes yet, but makes it much easier to adjust costs as
we progress.
https://invent.kde.org/qt/clang/llvm/-/commit/7c40a1d796cec2207bc697d94355a71962ee33df

Git commit b679982e67d34e8afa925691715aa69e06ea7e80 by GitHub (on behalf of Florian Hahn) on 21/07/2026 at 13:32..
[VPlan] Remove additional stray whitespace when printing calls. (#210979)

VPWidenCallRecipe::print had a stray whitespace between call and
fucntion name. Strip stray whitespace and add strict whitespace test to
guard against regressions.
https://invent.kde.org/qt/clang/llvm/-/commit/b679982e67d34e8afa925691715aa69e06ea7e80

Git commit c3e48dfd552de502f778f1b190933944a62cf75a by GitHub (on behalf of Joel E. Denny) on 21/07/2026 at 13:38..
[FileCheck][NFC] Encapsulate more into InputAnnotationLabeler (#207484)

This patch migrates more label-making concerns from
buildInputAnnotations into the InputAnnotationLabeler. It also
eliminates the brittle approach of creating a new InputAnnotationLabeler
object with a separate label prefix upon each MatchResultDiag while
persisting an object to close the previous search range. Instead, this
patch creates just one InputAnnotationLabeler object to handle all
diags, and it maintains a table of label prefixes for check patterns.
That approach seems easier to understand and more amenable to code
evolution.
https://invent.kde.org/qt/clang/llvm/-/commit/c3e48dfd552de502f778f1b190933944a62cf75a

Git commit c49595f5ce2f59a21e0c929254af7f0d6ed0e5c6 by GitHub (on behalf of Nerixyz) on 21/07/2026 at 13:38..
Revert "[lldb][Windows] Only embed Python home in Debug config (#209464)" (#210989)

This reverts commit 5a19a3a4b9915d19fff1b8298e723ee2b24ebc6a.

To fix a failure with MinGW
(https://github.com/llvm/llvm-project/pull/209464#issuecomment-5034222807).
https://invent.kde.org/qt/clang/llvm/-/commit/c49595f5ce2f59a21e0c929254af7f0d6ed0e5c6

Git commit ba836590ffed1305a770fc18f4a3f676f9829df1 by GitHub (on behalf of David Green) on 21/07/2026 at 13:42..
[SDAG] Use DAG.getTokenFactor in more places (#210949)

This will cause the TokenFactor to be split into nodes of at most
SDNode::getMaxNumOperands() size.

This fixes #189161 but I have not added a test case as the output is
in excess of 160000 lines long.
https://invent.kde.org/qt/clang/llvm/-/commit/ba836590ffed1305a770fc18f4a3f676f9829df1

Git commit 9eac681359c922aff608612eda0a0adc15106213 by GitHub (on behalf of Soham Karandikar) on 21/07/2026 at 14:02..
[Flang] [OpenMP] Run `MarkDeclareTarget` pass again before `HostOpFiltering` (#210049)

Fixes #209123.

The power operation `math.ipowi` is converted to a function by
`ConvertMathToFuncs`. When used in a target region, this pass runs well
after `MarkDeclareTarget` which causes the newly created power function
to not have the `omp.declare_target` attribute, which in turn trips up
the `HostOpLowering` pass. Detailed investigation
[here](https://github.com/llvm/llvm-project/issues/209123#issuecomment-4991765854).

Right now, I've just added a couple of lines to run `MarkDeclareTarget`
again, before `HostOpFiltering`. Since I'm quite new to this, I'd like
some help on whether this is acceptable, or should the
`MarkDeclareTarget` pass be moved to after `ConvertMathToFuncs` and
before `HostOpFiltering`.
https://invent.kde.org/qt/clang/llvm/-/commit/9eac681359c922aff608612eda0a0adc15106213

Git commit 7cd9cee53617d526c3526d01426ba552f2a825bb by GitHub (on behalf of Simon Pilgrim) on 21/07/2026 at 14:09..
[CostModel][X86] getArithmeticReductionCost - add missing type split handling for AVX512 types (#210994)
https://invent.kde.org/qt/clang/llvm/-/commit/7cd9cee53617d526c3526d01426ba552f2a825bb

Git commit e5a5c5dfdb4ac6b004ab31df25c30f4cc8772afe by GitHub (on behalf of Abid Qadeer) on 21/07/2026 at 14:12..
[flang][OpenMP] Add semantic checks for two DECLARE VARIANT restrictions (#209528)

Diagnose two DECLARE VARIANT restrictions from the OpenMP specification
(5.2 [7.5], 6.0 [9.6]) that were previously accepted without error:
- If a procedure is determined to be a function variant through more
than one DECLARE VARIANT directive, the construct selector set of their
context selectors must be the same.
- A procedure determined to be a function variant may not be specified
as a base function in another DECLARE VARIANT directive.

Assisted-by: Cursor
https://invent.kde.org/qt/clang/llvm/-/commit/e5a5c5dfdb4ac6b004ab31df25c30f4cc8772afe

Git commit f82f9693fa3a9bee4e045a06417740586cfbf207 by GitHub (on behalf of Vladislav Dzhidzhoev) on 21/07/2026 at 14:16..
[DirectX] Add slim debug support (#204459)

When DXC is called with `/Zs` flag, it emits "slim" debug info. It means
that ILDB section is omitted from the main DXContainer output and from
the output PDB file.

This patch reimplements similar behavior in llc, introducing
`--dx-slim-debug` flag.
https://invent.kde.org/qt/clang/llvm/-/commit/f82f9693fa3a9bee4e045a06417740586cfbf207

Git commit b02de9d35e7aad5b1dfb6dd8bc759bb8fa2d539f by GitHub (on behalf of nvmitch) on 21/07/2026 at 14:18..
[GlobalISel] Use correct fp semantics when building constants. (#210190)

This bug can materialize as a `bfloat 1.0` becoming `0x3C00` which is
the bit pattern for `half 1.0`. After this change, `0x3F80` is correctly
returned.
The fix is to use the destination type to convert the provided
constant's semantics in `buildFConstant`. Added a unit test.
Removed `getAPFloatFromSize`, no more users.
https://invent.kde.org/qt/clang/llvm/-/commit/b02de9d35e7aad5b1dfb6dd8bc759bb8fa2d539f

Git commit 17ac8fdd95283110a14f1de8c15a0fc661119296 by GitHub (on behalf of Louis Dionne) on 21/07/2026 at 14:21..
[libc++] Don't require complete types in vector<T>::empty() (#210754)

This was previously not required, but the patch to introduce a new
size-based vector layout unintentionally added this new requirement. We
almost certainly not want to promise this guarantee going forward, but
we should actually land this change explicitly and consider the
transition story, not do it as a fallout of another refactoring.

Fixes #210732
https://invent.kde.org/qt/clang/llvm/-/commit/17ac8fdd95283110a14f1de8c15a0fc661119296

Git commit 754c2bc62d1db7af5e65fe707705606d5482c61e by GitHub (on behalf of Aleksandr Popov) on 21/07/2026 at 14:31..
[SCEV][NFC] Precommit tests for MatchRangeCheckIdiom through zext (#210978)

'zext(X - 1) ult C'  =>  'X in [1, C+1)'; 
also ugt case (wrapping range)

Alive2 proof: https://alive2.llvm.org/ce/z/zcdv_2
https://invent.kde.org/qt/clang/llvm/-/commit/754c2bc62d1db7af5e65fe707705606d5482c61e

Git commit 7b159b648bc3684da152a3f14b5ee53456736fe9 by GitHub (on behalf of Corentin Jabot) on 21/07/2026 at 14:33..
[Clang] Defaults `-Wunicode-whitespace` to an error. (#210945)

Clang accepts some Unicode whitespaces in some context. There are a few
issues with this:
 - The support is incomplete and inconsistent, as illustrated in #38934
- We are not consistent with the Unicode specs (tr1, tr55) in that we
treat U+0028/0+0029 as horizontal separators while Unicode consider them
vertical.

Ultimately, Unicode whitespaces are more likely than not unintended.
Neither GCC nor MSVC support this extension.

Fixes #38934.
https://invent.kde.org/qt/clang/llvm/-/commit/7b159b648bc3684da152a3f14b5ee53456736fe9

Git commit 444ea3e6353a00c274fa19e2839cfcfc2cdfab36 by GitHub (on behalf of Petar Avramovic) on 21/07/2026 at 14:33..
AMDGPU/GlobalISel: Clean up fp LLT usage in AMDGPULegalizerInfo (#210999)

Remove local variables in favor of global F16/BF16/F32/F64/V2F16/V2BF16.
These are now proper floating point LLTs instead of LLT::scalar.
A couple of legalizer actions now use fp extended LLT for type checks.
This is intended and is planned for all floating point opcodes.
In most cases the current S16/S32/S64 action on floating point opcodes was
intended for F16/F32/F64, and we will need to define an action for BF16.
https://invent.kde.org/qt/clang/llvm/-/commit/444ea3e6353a00c274fa19e2839cfcfc2cdfab36

Git commit 119b31fd30644157b9429d122f777c6ae2e34a09 by GitHub (on behalf of Adel Ejjeh) on 21/07/2026 at 14:40..
[DAGCombiner] Fold NaN-guard fptosi/fptoui select to saturating variant (#201435)

Fold select (setcc X, 0, SETUO), 0, (fp_to_sint/fp_to_uint X) to
fp_to_sint_sat/fp_to_uint_sat in the generic DAG combiner, gated by
shouldConvertFpToSat. Also handles the SETO form with swapped arms, and
looks through an AND mask on the conversion result. Lit tests added for
AMDGPU and AArch64.

Assisted-by: Claude Code
https://invent.kde.org/qt/clang/llvm/-/commit/119b31fd30644157b9429d122f777c6ae2e34a09

Git commit 53199a1b9216a15d13da824c9140daf8863438aa by GitHub (on behalf of Lucas Mellone) on 21/07/2026 at 15:20..
[libc++][ranges] Mark LWG3664 as resolved (#210550)

Closes https://github.com/llvm/llvm-project/issues/105066.

When libc++ implemented `ranges::distance` in
c965d5448ecdf9a5513983862a78a2ba8f7fbab8, LWG3664 was implemented
together. The patch additionally changed cast result type from `const
decay_t<I>&` to `decay_t<I>`, which partially implemented LWG4242.

Currently, we are using `iter_difference_t<_Ip>` as the return type of
one `operator()` overload while LWG3664 modified that overload to return
`iter_difference_t<decay_t<_Ip>>`. The change is NFC because when
`iter_difference_t<decay_t<_Ip>>` is valid, `iter_difference_t<_Ip>` is
also valid and denotes the same type.

References:
- https://wg21.link/LWG3664
- https://eel.is/c++draft/range.iter.op.distance

---------

Co-authored-by: A. Jiang <[email protected]>
https://invent.kde.org/qt/clang/llvm/-/commit/53199a1b9216a15d13da824c9140daf8863438aa

Git commit 4f58fc26ad7652cdcfda3e6d50a372241265ee2b by GitHub (on behalf of Corentin Jabot) on 21/07/2026 at 15:22..
[Clang] Yet more consistent Unicode diagnostics (#211002)

This PR
- Use the recently introduced `EscapeSingleCodepointForDiagnostic` in
more places
- Fix a bug where U+FEFF was incorrectly treated as a BOM and therefore
did not render at all in diagnostics
https://invent.kde.org/qt/clang/llvm/-/commit/4f58fc26ad7652cdcfda3e6d50a372241265ee2b

Git commit 2f721aef85accd57afdb3e6bdb6e6fa5d5629579 by GitHub (on behalf of Domenic Nutile) on 21/07/2026 at 15:22..
[AMDGPU] Upstream True16 runlines for various tests (#209891)
https://invent.kde.org/qt/clang/llvm/-/commit/2f721aef85accd57afdb3e6bdb6e6fa5d5629579

Git commit 2542743b1507ace8d05d894f5ec5135e9a9863ba by GitHub (on behalf of Abhina Sree) on 21/07/2026 at 15:22..
[SystemZ] Enable clang-target-64-bits for s390x (#210361)

Enable clang-target-64-bits for s390x so we can enable tests like
https://github.com/llvm/llvm-project/pull/210341
https://invent.kde.org/qt/clang/llvm/-/commit/2542743b1507ace8d05d894f5ec5135e9a9863ba

Git commit 162d9f09299d3951d7c73e6aa00f2e2bac459e26 by GitHub (on behalf of Max Desiatov) on 21/07/2026 at 15:34..
[lld][WebAssembly] Preserve segment linking flags in --relocatable output (#210747)

`OutputSegment::addInputSegment` copied each input chunk's alignment but
never its flags, so a relocatable link serialized `flags=0` for every
data segment and dropped `RETAIN` and `STRINGS`. Losing `RETAIN` let the
final default `--gc-sections` link discard runtime-registered sections
such as Swift's `swift5_*` metadata, corrupting the program. This unions
each input segment's flags into the output segment's `linkingFlags` and
adds a `lld/test/wasm` test covering `RETAIN`, `STRINGS`, and flag
accumulation across coalesced segments.

Resolves
https://github.com/swiftlang/swift-package-manager/issues/10314.
https://invent.kde.org/qt/clang/llvm/-/commit/162d9f09299d3951d7c73e6aa00f2e2bac459e26

Git commit 853ab6e38bc7c796029596fcc8d314105dd823d2 by GitHub (on behalf of Hugo Trachino) on 21/07/2026 at 15:40..
[MLIR][Linalg] Fix FlattenElementwiseOp for linalg.broadcast (#210738)

Follow-up of https://github.com/llvm/llvm-project/pull/207005 
The added test 'unsupported_dim_expanding_broadcast' passed with
broadcast-like 'linalg.generic' but failed with a 'linalg.broadcast'.
Generating an incorrect `linalg.collapse_shape` raising error `op number
of elements must be preserved` upon flattening. This patch prevents
broadcasting ops to be targeted by this op while allowing 0-D to N-D
broadcasting to take place as for linalg.fill.

I removed the negative test
`unsupported_rank_expanding_broadcasting_elementwise` as it had been
mentioned in the previous MR that it was repeating the above
`unsupported_broadcasting_elementwise` test.
https://invent.kde.org/qt/clang/llvm/-/commit/853ab6e38bc7c796029596fcc8d314105dd823d2

Git commit b4ef17b8c77260f8ca9229f1b764dadbf0c1348c by GitHub (on behalf of Erich Keane) on 21/07/2026 at 15:40..
[OpenACC] Better handle error overloaded ops in ForStmtChecker (#211005)

The OpenACC 'loop' constructs do a bunch of checking on the contents of
a ForStmt. However, in cases of overloaded operators, some of the
checking we assumed happened (like operators having a certain number of
    args) doesn't hold in the case of errors.  This patch adds some
guards to make sure we error-out if the number of args doesn't match
what we're expecting everywhere I could find it.

Fixes: #210958
https://invent.kde.org/qt/clang/llvm/-/commit/b4ef17b8c77260f8ca9229f1b764dadbf0c1348c

Git commit 15ec65a698e10cf693c158c05cf49351c9b1618c by GitHub (on behalf of Erich Keane) on 21/07/2026 at 15:40..
[OpenACC] Make sure our 'init' recipe handles nullptr_t (#211008)

The bug report shows that we missed one scalar type in our
initialization code, nullptr_t! This patch adds the initializer to make
sure it works correctly, and adds the test (plus a non-template
    version).

Fixes: #210877
https://invent.kde.org/qt/clang/llvm/-/commit/15ec65a698e10cf693c158c05cf49351c9b1618c

Git commit d534912565bd46fe4c031c46c5204db3ec03dbed by GitHub (on behalf of adams381) on 21/07/2026 at 15:51..
[CIR] Add x86_64 aggregate calling-convention lowering (#210528)

The x86_64 SysV calling-convention bridge in CallConvLowering so far handles only scalar arguments and returns.  A function with a struct or array parameter is reported NYI.  This teaches the bridge to classify struct and array aggregates.

A struct is mapped to an `llvm::abi` record built from the DataLayout field offsets and the CanPassInRegisters flag on the module's `cir.record_layouts` metadata, and an array maps to an `llvm::abi` array.  The library's classifier then produces the ArgInfo, either Direct with a coerced register type the existing rewriter flattens, or Indirect via sret, byval, or byref.  CIRABIRewriteContext already applies all of these, so this only feeds it the aggregate classifications and leaves the scalar path untouched.

Aggregate shapes the bridge does not yet classify stay errorNYI, so an unsupported signature fails cleanly instead of being misclassified.  Those are unions (whose register coercion needs a widen fixup), packed and over-aligned records, empty-for-ABI records, and `_BitInt`.  All-float aggregates such as a two-`float` struct or `float[2]` are included too.  Their SSE class coerces to a `<2 x float>` vector the bridge cannot yet represent, so instead of passing the aggregate through unchanged it reports the coercion as NYI.

The byval and sret argument attributes still carry the CIR record type.  Converting that to the LLVM type in LowerToLLVM is a separate change, so the byval and sret tests check the CIR output only, while the direct and flatten tests also check the lowered LLVM IR.
https://invent.kde.org/qt/clang/llvm/-/commit/d534912565bd46fe4c031c46c5204db3ec03dbed

Git commit 16b44e00cc3754ea14b6873c885754af56d316e5 by GitHub (on behalf of Matt Arsenault) on 21/07/2026 at 15:56..
AMDGPU: Do not report inline immediates as legal for generic operands (#208216)

This has one test change in an SI_CS_CHAIN_TC* test. Either this is fine
or the instruction definition should be changed.
https://invent.kde.org/qt/clang/llvm/-/commit/16b44e00cc3754ea14b6873c885754af56d316e5

Git commit effb51959f01e4b70dac8f61fc740c550c101e23 by GitHub (on behalf of Matt Arsenault) on 21/07/2026 at 15:56..
AMDGPU: Constant fold instructions with inline immediate operands (#208422)

Previously we would only try to perform constant folding and
simplifications when an immediate was folded into an instruction, 
not if the input was already a folded constant.

Co-authored-by: Claude (Opus 4.8) <[email protected]>
https://invent.kde.org/qt/clang/llvm/-/commit/effb51959f01e4b70dac8f61fc740c550c101e23

Git commit 1301a69bc23e3dbf9e60e7ca2acc8171bb358bac by GitHub (on behalf of Patrick Simmons) on 21/07/2026 at 15:58..
Fix Strong VTables Accidentally Emitted by #159856 (#200942)

Users have reported link errors due to duplicate vtables after the merge
of #159856. Root cause analysis revealed that these errors were due to
the VTables emitted in `CGOpenMPRuntime::emitAndRegisterVTable`, which
was added by PR #159856. This PR fixes the issue by changing that
function to emit its VTables as weak symbols.
https://invent.kde.org/qt/clang/llvm/-/commit/1301a69bc23e3dbf9e60e7ca2acc8171bb358bac

Git commit 315c8bba65673457cd118f167ce2fa62f1347e9e by GitHub (on behalf of Benjamin Luke) on 21/07/2026 at 16:04..
Reland "[clang][CodeGen][X86_64] Honor per-function AVX ABI in C/C++ call paths, maintain old psABI for PlayStation." (#210349)

https://github.com/llvm/llvm-project/pull/193298 was reverted because of
a compile time regression (see results
[here](https://llvm-compile-time-tracker.com/compare.php?from=b9869c8c920a7dfa983e215bc30729b13d8b353b&to=464b46a73b7592c95222cf2e64b34ffe6f2cf251&stat=instructions:u))

I added a conditional statement so that getFunctionFeatureMap and the
subsequent string lookup is only called if FD->hasAttr<TargetAttr>()
evaluates to true which should be very rare.

---------

Co-authored-by: Aaron Ballman <[email protected]>
https://invent.kde.org/qt/clang/llvm/-/commit/315c8bba65673457cd118f167ce2fa62f1347e9e

Git commit ec8e379cac62ddbad5d0319be0cf2369fa5102c9 by GitHub (on behalf of Ian Li) on 21/07/2026 at 16:11..
[NFC][Clang] Remove dead code from LifetimeSafety/FactsGenerator.cpp (#210830)

This PR removes dead code in
`clang/lib/Analysis/LifetimeSafety/FactsGenerator.cpp`. This was
discovered by a Coverity scan on clang.
https://invent.kde.org/qt/clang/llvm/-/commit/ec8e379cac62ddbad5d0319be0cf2369fa5102c9

Git commit b59caeffc273ddd057b7a5d0f1129afbfa3b3c7b by GitHub (on behalf of Ebuka Ezike) on 21/07/2026 at 16:12..
[lldb-dap] Migrate lldb-dap events tests. (#209285)

Migrate
- TestDAP_breakpointEvent.py
- TestDAP_eventStatistic.py
- TestDAP_invalidatedEvent.py
- TestDAP_sendEvent.py
- TestDAP_stopped_events.py
- TestDAP_terminatedEvent.py

Some test's helper methods are no longer necessary as there is already
existing session function doing something similar.
https://invent.kde.org/qt/clang/llvm/-/commit/b59caeffc273ddd057b7a5d0f1129afbfa3b3c7b

Git commit 19822360d87121ac12d201997bf82af94926ef36 by GitHub (on behalf of asraa) on 21/07/2026 at 16:13..
[mlir][Analysis][Presburger] Remove redundant local vars after composition (#211023)

Call `removeRedundantLocalVars()` at the end of
`IntegerRelation::compose` to simplify existential constraints generated
when projecting out intermediate dimensions.

Removing redundant local vars also happens in
`IntegerRelation::mergeAndCompose` and `FlatAffineRelation::compose`.

When composing A->B with B->C, intermediate vars B are converted to
local existential variables. When performing multiple compositions, this
causes bloat of existential variables that impact later performance,
bounds checks, and emptiness checks.

Signed-off-by: Asra Ali <[email protected]>
https://invent.kde.org/qt/clang/llvm/-/commit/19822360d87121ac12d201997bf82af94926ef36

Git commit 5b1fa37be65be730784a675c40b15d5a702f38ab by GitHub (on behalf of Andy Ames) on 21/07/2026 at 16:17..
[analyzer] Fix crash in RegionStoreManager::bindArray from constructor array-to-pointer decay (#210649)

ProcessInitializer() strips implicit casts from a CXXCtorInitializer's
init expression via IgnoreImplicit(), then decides whether to treat the
initializer as a direct array-to-array member copy by checking
Init->getType()->isArrayType(). For a pointer member initialized via
array-to-pointer decay of a reference-to-array constructor parameter
(e.g. `Foo(T (&arr)[N]) : ptr_(arr) {}`), IgnoreImplicit() strips the
ArrayToPointerDecay cast, exposing the underlying array-typed
expression, so this check misfires even though the field itself is a
pointer, not an array. That branch fetches the raw region address of the
whole array, bypassing the normal decay logic (which produces an
ElementRegion), so the pointer member ends up holding the address of the
whole array typed as the array itself, instead of an ElementRegion at
index 0.

Later, dereferencing and storing through that mistyped pointer routes
into RegionStoreManager::bindArray() (instead of bindScalar()), which
unconditionally casts its Init value to nonloc::CompoundVal, asserting
in a debug build and segfaulting in a release build when Init is
anything else, e.g. a nonloc::LocAsInteger produced by round-tripping a
pointer through an integer type.

Fix the actual bug by checking the field's type instead of the
initializer expression's type. Also generalize bindArray()'s existing
guard (added by #178923 for issue #178797) from an enumeration of
specific SVal kinds to the same exhaustive
`!isa<nonloc::CompoundVal>()` check already used by its siblings
bindStruct() and bindVector(), so it doesn't need to be extended again
every time a new SVal kind reaches this path -- this is what actually
catches our case (nonloc::LocAsInteger), which the prior enumeration
didn't cover.

This is the same underlying bug behind #147686 (fixed by #153177, which
its own author noted was "more of a workaround") and #178797 (fixed by
#178923); both those fixes patched symptoms at bindArray() without
addressing the ProcessInitializer() root cause. Fixing the root cause
also resolves two FIXME-annotated precision gaps in
clang/test/Analysis/initializer.cpp's gh147686 regression test.

Fixes #210183

AI tool use disclosure: Claude Code (Anthropic) assisted in reducing the
original crash to a minimal, dependency-free reproducer (via creduce
plus manual bisection, verifying each reduction step against the actual
crash), which informed root-causing this bug in
RegionStoreManager::bindArray and ExprEngine::ProcessInitializer. The
commits made here were drafted with Claude's assistance and reviewed by
me before being pushed. I've reviewed all AI-assisted contributions here
and take full responsibility for the correctness of this change.

---------

Co-authored-by: Andy Ames <[email protected]>
Co-authored-by: Balázs Benics <[email protected]>
https://invent.kde.org/qt/clang/llvm/-/commit/5b1fa37be65be730784a675c40b15d5a702f38ab

Git commit 0f398c5f1a26ee67ed500e85c91759610cccc3fe by GitHub (on behalf of Vito Secona) on 21/07/2026 at 16:23..
[mlir][SparseTensor] Reject sparse encoding on non-primary types (#209591)

SparseTensorConversion rewrite patterns assume element types are valid
primary types, but the dialect does not actually enforce this
restriction. This change makes it so that sparse tensor encodings
gracefully reject invalid primary types by verifying the encoding.

Closes #202787
Supersedes and closes #208913
https://invent.kde.org/qt/clang/llvm/-/commit/0f398c5f1a26ee67ed500e85c91759610cccc3fe

Git commit ac5aea3e462726d6ad44332b1de2e74638804947 by GitHub (on behalf of Matt Arsenault) on 21/07/2026 at 16:37..
AMDGPU: Validate processor and features in TargetID parsing (#209304)

TargetID::parseTargetIDString previously only checked that the string
was structurally a 4-component triple followed by a processor field. It
accepted unrecognized processors and silently ignored malformed or
unsupported feature modifiers. Work towards improving validation so in
the future clang's copy of TargetID can be replaced.

Co-authored-by: Claude (Opus 4.8)
https://invent.kde.org/qt/clang/llvm/-/commit/ac5aea3e462726d6ad44332b1de2e74638804947

Git commit c991dbda3184943378b115699f60f51cca0af1fa by GitHub (on behalf of ustachow) on 21/07/2026 at 16:40..
[MemorySSA] Make getPreviousDef iterative to avoid stack overflow (#205159)

MemorySSAUpdater::getPreviousDefRecursive walked the CFG
predecessor-first
using native recursion (mutually recursive with getPreviousDefFromEnd).
On
functions with very deep control flow - e.g. long chains of blocks
produced
by large auto-generated kernels/shaders - the recursion depth scales
with the
number of blocks and can overflow the native stack.

Rewrite the walk as an explicit worklist of frames on the heap. Each
frame
tracks the block being processed and a resume stage so a child block's
result
can be folded back into its parent, exactly mirroring the previous
recursive
control flow. Behaviour is otherwise unchanged: cache lookups,
VisitedBlocks
cycle detection (including the single-predecessor insert-without-erase
asymmetry), predecessor operand order, and phi placement/simplification
are
all preserved. The helper is renamed getPreviousDefRecursive ->
getPreviousDefIterative since it no longer recurses.

Add a unit test that builds a long single-predecessor chain and
incrementally
updates MemorySSA; the previous recursive implementation overflowed the
stack
on such input.

Fixes: https://github.com/llvm/llvm-project/issues/121279
https://invent.kde.org/qt/clang/llvm/-/commit/c991dbda3184943378b115699f60f51cca0af1fa

Git commit e959a280d5ac91d219abb802913c4e5cadb45f2a by GitHub (on behalf of Valentin Clement (バレンタイン クレメン)) on 21/07/2026 at 16:47..
[mlir][openacc] Do not erase acc routine information early (#210813)

acc routine information is used in ACCCGToGPU to compute parallelism. If
the info is missing, predicated region might be wrong and lead to
deadlock.

Just keep them in ACCRountineToGPUFunc and they will be cleaned up later
in the pipeline.
https://invent.kde.org/qt/clang/llvm/-/commit/e959a280d5ac91d219abb802913c4e5cadb45f2a

Git commit 9b362c71c51a45871d5fe337c7da7ff1ed9fe0cb by GitHub (on behalf of David Young) on 21/07/2026 at 16:48..
[bazel] Only set LLVM_ENABLE_DIA_SDK in bazel build defs to zero if not set by build args (#210723)

Windows lldb build support via bazel is still a work in progress.
LLVM_ENABLE_DIA_SDK enables windows specific functionality. With it
hard-coded to 0 here, an override via build args via buck2 (internally
at Meta) of
'-DLLVM_ENABLE_DIA_SDK=1' had no effect. So modify this set of
configurations to allow that build arg to take precedence while avoiding
a larger amount of changes for windows/bazel lldb support (for now).

As cannot build with bazel locally, I will rely on CI to confirm lint
and building.
https://invent.kde.org/qt/clang/llvm/-/commit/9b362c71c51a45871d5fe337c7da7ff1ed9fe0cb

Git commit 350c2d86228f330d986f6c8cd63899cd147427c3 by GitHub (on behalf of Lucas Ramirez) on 21/07/2026 at 16:54..
[AMDGPU] Fix `GCNRegPressureTest`'s super-class to ensure proper target initialization (#211030)

The typo made it so that all tests in the file would be skipped if no
other testsuite explicitly initialized the AMDGPU target (for example
when running `./unittests/Target/AMDGPU/AMDGPUTests
--gtest_filter=GCNRegPressureTest.*`). `AMDGPUCodeGenTestBase`
initializes the target so tests always run as long as LLVM is built with
the AMDGPU target.
https://invent.kde.org/qt/clang/llvm/-/commit/350c2d86228f330d986f6c8cd63899cd147427c3

Git commit d53ebd23aabd9286075650b663ff0bcbbef9ebd8 by GitHub (on behalf of Tom Stellard) on 21/07/2026 at 17:03..
workflows/release-documentation: Fix typo (#210815)

GITHUB_OUT -> GITHUB_OUTPUT
https://invent.kde.org/qt/clang/llvm/-/commit/d53ebd23aabd9286075650b663ff0bcbbef9ebd8