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

Git repository change summary for qt/clang/llvm-project
Pushed by mirror-service into branch 'upstream/users/wangpc-pp/spr/riscv-cost-i64-accumulator-for-zvdot4a8i-partial-reductions'.
Changed from 0000000000000000000000000000000000000000 to 5ca6ab9719533dd82d732673ed055dbf5042c119
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 a4bea9975fbe73b02dfeffe896695494e1c19df9 by GitHub (on behalf of John Otken) on 14/08/2026 at 11:36..
[flang] Add warning when BOZ literal is too large for assignment (#210749)

Generate a warning when a BOZ literal assignment does not fit into the
left-hand side variable.

AI use disclaimer: Github CoPilot assisted with this PR. I manually
reviewed and tested the code.

Co-authored-by: John Otken [email protected]

---------

Co-authored-by: John Otken <[email protected]>
https://invent.kde.org/qt/clang/llvm-project/-/commit/a4bea9975fbe73b02dfeffe896695494e1c19df9

Git commit 207f72d5c5fe53c9eb4f1eae7be9869f641186a4 by GitHub (on behalf of Charles Zablit) on 14/08/2026 at 12:04..
[lldb] introduce the requireMacOS decorator (#216135)

This is not used in llvm.org yet, but will be used in swiftlang with
https://github.com/swiftlang/llvm-project/pull/13750.
https://invent.kde.org/qt/clang/llvm-project/-/commit/207f72d5c5fe53c9eb4f1eae7be9869f641186a4

Git commit f5418f338116805c3946fe5ddf13d3f5b536ec68 by GitHub (on behalf of Phoebe Wang) on 14/08/2026 at 12:15..
[X86][APX] Add missing VRM argument (#216240)

It happens when a rematerialized load is from global variable, see
https://godbolt.org/z/ddsh8PP4K

Assisted-by: Claude Opus 4.8
https://invent.kde.org/qt/clang/llvm-project/-/commit/f5418f338116805c3946fe5ddf13d3f5b536ec68

Git commit 0132fac13fdc5d3ec08ee71ab7bf1626152c7198 by GitHub (on behalf of Ebuka Ezike) on 14/08/2026 at 12:16..
[lldb-dap] Spawn debug sever in the build directory. (#216078)

The debugserver may create files such as the socket in the working
directory.
https://invent.kde.org/qt/clang/llvm-project/-/commit/0132fac13fdc5d3ec08ee71ab7bf1626152c7198

Git commit 42b0f565056c08d190d718d9ca000b5b0d4bce1b by GitHub (on behalf of Paul Walker) on 14/08/2026 at 12:26..
[LLVM][CodeGen][SVE] Prefer uadalp over sabalb/sabalt. (#216301)

Partially reverts https://github.com/llvm/llvm-project/pull/212800
becuase for SVE2 using uadalp has better accumulator throughput than a
sabalb/sabalt sequence.
https://invent.kde.org/qt/clang/llvm-project/-/commit/42b0f565056c08d190d718d9ca000b5b0d4bce1b

Git commit 17930a3c97d8f861a4c69e8b2903524aed84edb8 by GitHub (on behalf of David Spickett) on 14/08/2026 at 12:32..
[lldb][AArch64][Linux] Add function to get register buffers (#213977)

Replaces Get<set>Buffer methods.
https://invent.kde.org/qt/clang/llvm-project/-/commit/17930a3c97d8f861a4c69e8b2903524aed84edb8

Git commit 1b3b7e5fe8214ac6ec67da6cb7b52c6eaee95c16 by GitHub (on behalf of mbhade-amd) on 14/08/2026 at 13:06..
[X86][PartialReduction] Lower zext-byte add reductions to vpsadbw (#201076)

Loops of the form `for (i) sum += bytes[i];` (`uint8_t` input, `i32`/`i64` accumulator)
lower to `vpmovzxbd` + `vpaddd` today, although `PSADBW(x, 0)`
computes the same sum in one instruction per 128/256/512-bit lane.

Teach `X86PartialReduction` to rewrite the `zext <N x i8> to <N x i32|i64>`
leaves of an add reduction (N >= 16) into `PSADBW(x, 0)`, split across
SSE2/AVX2/AVX-512BW lanes per the subtarget. `i64` accumulators consume
`PSADBW`'s natural `<N/8 x i64>` output directly.

Tests: `x86-partial-reduction-byte-sum*.ll` (matcher in isolation),
`byte-sum-{positive,negative}.ll` (full CodeGen on +sse2/+avx2/+avx512bw).
https://invent.kde.org/qt/clang/llvm-project/-/commit/1b3b7e5fe8214ac6ec67da6cb7b52c6eaee95c16

Git commit 42a986f70324651426cd7e287580160766fc906f by GitHub (on behalf of Nikolas Klauser) on 14/08/2026 at 13:10..
[libc++] Upgrade to GCC 16 (#206235)

This also removes a few `// UNSUPPORTED: gcc` which are unnecessary as a
drive-by.
https://invent.kde.org/qt/clang/llvm-project/-/commit/42a986f70324651426cd7e287580160766fc906f

Git commit ff5e78029034e56a1a26d5f2d051f6a9b2ea2900 by GitHub (on behalf of Wooseok Lee) on 14/08/2026 at 13:33..
[AMDGPU] Fix performFMACombine FDOT2 fold for subnormal handling (#205101)

The fold from v_fma_mix_f32 pairs to v_dot2_f32_f16/v_dot2c_f32_f16
was gated only on fp-contract flags, ignoring how each instruction
handles f16 subnormal inputs under different denormal modes.

Hardware testing across multiple GPU generations shows that gfx90a
(CDNA2) is the sole outlier: v_dot2c unconditionally flushes f16
subnormal inputs to zero in all MODE configurations, while v_fma_mix_f32
preserves them when ieee=1 (the default compute kernel mode). All other
tested GPUs with dot2 instruction do not flush f16 subnormal inputs.
Add GCNSubtarget::dot2UnconditionalFlush() to capture this hardware
quirk.

Gate the fold on the function's f32 denormal mode:
- dot2UnconditionalFlush(): allow fold only when f32 denorm =
  PreserveSign, so both instructions flush f16 subnormals.
- All other GPUs: allow fold only when f32 denorm = IEEE, so both
  instructions preserve f16 subnormals. Dynamic mode is also rejected
  since the runtime value is unknown.

When both FMAs carry the afn (approximate functions) flag, the caller
has already opted into imprecise results, so any subnormal flushing
introduced by dot2 is acceptable. The denormal mode check is skipped
in that case regardless of GPU or mode.

Update fdot2.ll: add GFX90A-PS and GFX90A-IEEE RUN lines to verify the
gfx90a-specific behavior. Update GFX906/GFX10 checks to reflect that
the fold is now blocked under preserve-sign and allowed under ieee.
https://invent.kde.org/qt/clang/llvm-project/-/commit/ff5e78029034e56a1a26d5f2d051f6a9b2ea2900

Git commit 52c14cc8eb9e52de62ecada4bc6d92030c748442 by GitHub (on behalf of Matt Arsenault) on 14/08/2026 at 13:38..
lli: Record the host triple on triple-less modules (#216132)

The JIT compiles for the host, but modules without a target triple kept
an empty triple, which module-triple-based analyses (e.g. runtime
libcall selection) cannot resolve. Set the resolved JIT triple on the
module. This defends against jit test regressions when
RuntimeLibraryInfo
starts getting computed from the module instead of TargetOptions.

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

Git commit 6b04339b88eb5e7f47233be197e6ba816f52d730 by GitHub (on behalf of babadany2999) on 14/08/2026 at 13:48..
[Clang][Sema] Fix an ICE where structured binding packs within a lambda were not added to the CapturingScopeInfo (#214716)

Fixed a bug where structured binding packs within a lambda were not
added to the `CapturingScopeInfo` during `ActOnDecompositionDeclarator`,
which also led to invalid expressions being considered for delayed
lambda diagnostics, when they should have been diagnosed immediately.

Fixes #214160

Signed-off-by: Baba Dan Constantin <[email protected]>
https://invent.kde.org/qt/clang/llvm-project/-/commit/6b04339b88eb5e7f47233be197e6ba816f52d730

Git commit cbf19fdf510a5b01832baa5145d393414c6750d6 by GitHub (on behalf of Ricardo Jesus) on 14/08/2026 at 13:54..
[AArch64][CostModel] Adjust the cost of pure partial add reductions. (#214723)

These reductions can lower to a [SU]ADALP rather than a widening add
pair, so using partial reductions becomes profitable for two-way
widening reduction loops such as (https://godbolt.org/z/v8vr9Pzqb):
```c
long sadalp(const int *a, long n) {
  long s = 0;
  for (long i = 0; i < n; i++)
    s += (long)a[i];
  return s;
}
```
https://invent.kde.org/qt/clang/llvm-project/-/commit/cbf19fdf510a5b01832baa5145d393414c6750d6

Git commit 3b7142cb221878ba5d10248aafd5ccfa38b35ced by GitHub (on behalf of Ebuka Ezike) on 14/08/2026 at 13:59..
[lldb-dap][NFC] Use wildcard imports for test decorators (#216235)

Replace explicit imports `from ... import (a, b, c)` with wildcard
imports `from ... import *` for `lldbsuite.test.decorators`,

This lets downstream forks introduce extra decorators (e.g. to skip
tests on private configurations) without needing to patch each test's
import list.

[Related
discourse](https://discourse.llvm.org/t/do-we-want-to-tighten-up-imports-in-the-api-testcases/91557/3)
https://invent.kde.org/qt/clang/llvm-project/-/commit/3b7142cb221878ba5d10248aafd5ccfa38b35ced

Git commit 3de6fef89d9f9eb602a5bdaa2a3fe2a75a468030 by GitHub (on behalf of davidlerner96) on 14/08/2026 at 14:10..
[mlir] Add shouldPromoteIfSingleIteration option to loopUnrollByFactor (#215080)

Add a shouldPromoteIfSingleIteration parameter to loopUnrollByFactor to
control whether single-iteration loops are promoted during unrolling.
When set to false, the function skips calls to promoteIfSingleIteration
on the main loop, epilogue loop, and the unroll-factor-1 early-exit
path.

The parameter defaults to true to preserve existing behavior.
https://invent.kde.org/qt/clang/llvm-project/-/commit/3de6fef89d9f9eb602a5bdaa2a3fe2a75a468030

Git commit 2184774554b4387f2ee6452e6e055023916824ea by GitHub (on behalf of Adam Smith) on 14/08/2026 at 14:23..
[CIR] Accept fixed-width vectors in x86_64 callconv lowering (#215118)

The CallConvLowering bridge rejects a vector in a parameter or return
position, so a function taking one fails the pass. It also never reads
the AVX level, which is what decides whether a vector wider than 128
bits reaches a register.

A vector is accepted now where the classifier and clang size it the same
way, which means a whole-byte element and a power-of-two width. Scalable
vectors and the other widths stay rejected. The module's AVX level comes
from the target ABI name, as `CodeGenModule` does. A classifier per
level lets a target attribute raise it for one function. An ABI older
than the rule pins every function back to the module's level. A direct
call takes its callee's level, and an indirect call the level of the
function containing it.

CIRGen records target features on a definition but not on a declaration,
so a declaration carrying the attribute is classified at the module's
level until [#214986](https://github.com/llvm/llvm-project/pull/214986)
lands.

Depends on [#215117](https://github.com/llvm/llvm-project/pull/215117)

Assisted-by: Cursor / claude-opus-5
https://invent.kde.org/qt/clang/llvm-project/-/commit/2184774554b4387f2ee6452e6e055023916824ea

Git commit 81ac5c7c26efb70ffaffb91b26053437093ee085 by GitHub (on behalf of Yury Plyakhin) on 14/08/2026 at 14:30..
[clang][NFC] Generalize -fcuda-include-gpubinary to -foffload-include-binary (#216090)

`-fcuda-include-gpubinary` names a finalized device binary to
incorporate into the host object file at compile time. Despite the name
it is already shared by CUDA and HIP, and the mechanism is not
CUDA-specific: any offloading model that finalizes device code per
translation unit (i.e. non-relocatable device code) needs it.

Rename the cc1 option to `-foffload-include-binary` and the
corresponding CodeGenOptions field from `CudaGpuBinaryFileName` to
`OffloadBinaryToEmbedFile`.

The offloading model in effect already determines how the binary is
incorporated, so a single option suffices.

`-fcuda-include-gpubinary` is kept as an alias so existing invocations
continue to work.

Co-authored-by: Claude
https://invent.kde.org/qt/clang/llvm-project/-/commit/81ac5c7c26efb70ffaffb91b26053437093ee085

Git commit a0a834799590d8cfa3191e910a60e1e5be6e32a5 by GitHub (on behalf of Simon Pilgrim) on 14/08/2026 at 14:51..
[DAG] narrowExtractedVectorLoad - add frozen load handling (#216120)

Fixes #216115
https://invent.kde.org/qt/clang/llvm-project/-/commit/a0a834799590d8cfa3191e910a60e1e5be6e32a5

Git commit d0f98d63f6ea03009f8105619ab0e922dd334564 by GitHub (on behalf of jinge90) on 14/08/2026 at 14:51..
[compiler-rt] Fix clang_rt.builtins spirv64 bitcode install component (#216276)

Install component for libclang_rt.builtins static archive library for
spirv64 is clang_rt.builtins-spirv64, libclang_rt.builtins bitcode
library install should use same component as static archive library.

Signed-off-by: jinge90 <[email protected]>
https://invent.kde.org/qt/clang/llvm-project/-/commit/d0f98d63f6ea03009f8105619ab0e922dd334564

Git commit c3a42a54dcc0c0737af62e1f79669ce72a20c289 by GitHub (on behalf of Nick Sarnie) on 14/08/2026 at 14:58..
[libsycl] Run unittests using lit (#214778)

Execute the libsycl unittests using `lit`, and set `PATH` to be correct
on Windows.

The motiviation for this change is we need to add the compiler bin and
lib directories to `PATH` on Windows as Linux relies on `rpath` which
doesn't exist on Windows, and it's much easier to do that in `lit`.

This matches what `liboffload` does for their unit tests, see
[here](https://github.com/llvm/llvm-project/blob/main/offload/test/unit/lit.cfg.py).

Co-Authored-By: Claude Opus 4.8 (1M context) <[email protected]>

Signed-off-by: Nick Sarnie <[email protected]>
Co-authored-by: Claude Opus 4.8 (1M context) <[email protected]>
https://invent.kde.org/qt/clang/llvm-project/-/commit/c3a42a54dcc0c0737af62e1f79669ce72a20c289

Git commit b79317f9877d805a5091b26dd1f2eb795b5aca05 by GitHub (on behalf of Maria Fernanda Guimarães) on 14/08/2026 at 14:58..
[clangd] Add hover support for statement attributes (#214318)

Hovering over `[unroll]`, `[loop]`, `[branch]`, or `[flatten]` should
display the attribute name and documentation about its effect on GPU
shader execution.

This patch extends clangd's `SelectionTree` to traverse attributes
attached to `AttributedStmt` nodes before visiting the underlying
statement.

Fixes #214067
https://invent.kde.org/qt/clang/llvm-project/-/commit/b79317f9877d805a5091b26dd1f2eb795b5aca05

Git commit 17460a5bad231004a5747aecae589abda06c537d by GitHub (on behalf of Benedek Kaibas) on 14/08/2026 at 15:02..
[analyzer] Only report the first dereference of the same variable in DanglingPtrDeref (#215409)

If the same variable is dereferenced multiple times then the
`DanglingPtrDeref` checker should only emit a single wanring for it
instead of multiple ones. If there are multiple variables dereferenced
then for each variable there should be one warning emitted. For that
reason I have implemented the `markAsReported` function which returns
the updated state with the memory region of the given variable marked as
reported if the memory region is seen for the first time.
https://invent.kde.org/qt/clang/llvm-project/-/commit/17460a5bad231004a5747aecae589abda06c537d

Git commit ceca5336c5d57555bd098ee630f140bf22502c17 by GitHub (on behalf of William Moses) on 14/08/2026 at 15:13..
[mlir][arith] Do not preserve nneg when folding extui of extui (#216315)

The `extui(extui(x))` fold reassigns the outer extension's source while
keeping its `nneg` flag. The flag asserts the source is non-negative as
a signed value, about which the outer flag says nothing once the source
changes:

```mlir
%w = arith.extui %b : i1 to i8
%r = arith.extui %w nneg : i8 to i32   // satisfied for every bool byte
```

folds to `arith.extui %b nneg : i1 to i32`, which is poison whenever
`%b` is true (the signed value of i1 `1` is −1). Downstream, LLVM is
then entitled to fold the bool to false everywhere the merged value
flows; we hit this as a real end-to-end miscompile where a kernel's
boolean-derived launch arguments were all evaluated with the flag's
false arm.

Keep `nneg` on the merged extension only if the inner extension carries
it — the inner flag is the one that speaks about the surviving source.

Assisted-By: Claude

---------

Co-authored-by: Claude Fable 5 <[email protected]>
https://invent.kde.org/qt/clang/llvm-project/-/commit/ceca5336c5d57555bd098ee630f140bf22502c17

Git commit 72edcedcdf0a8de68338e9b42f4effd1f21e9725 by GitHub (on behalf of Nick Sarnie) on 14/08/2026 at 15:18..
[libsycl][unit] Mock 3 missing liboffload functions for unit tests (#216170)

We missed mocking these three functions that are never called in our
current tests but are used in `libsycl`, it happens to not fail on Linux
due to a linker optimization (`-ffunction-sections` and `--gc-sections`)
that happens to kick in so we never actually try to resolve these
symbols on Linux.

Windows does't have the same optimization (or at least, it's not
enabled), so compiling the unit tests throws a linker error.

Mock the functions so we can compile/link `check-sycl` on Windows.

With this PR and my previous one moving the tests to `lit`, `check-sycl`
passes on Windows!

Co-authored-by: Claude Opus 4.8 (1M context) <[email protected]>
https://invent.kde.org/qt/clang/llvm-project/-/commit/72edcedcdf0a8de68338e9b42f4effd1f21e9725

Git commit 828d2d7fb65a9cd5946b347ad5173e3bdb21387d by GitHub (on behalf of Daniel Chen) on 14/08/2026 at 15:33..
[Support][test] Fix OpenDirectoryAsFileForRead test on AIX and z/OS (#216241)

Commit 9c7ba7b1d12e ("[AIX][SystemZ][Support] Check if file is dir on
open instead of read") moved the `fstat`/`EISDIR` check from
`readNativeFile()` to `openNativeFileForRead()` on AIX and z/OS. This
means `openNativeFileForRead()` now returns `EISDIR` immediately on
those
platforms, but the test `FileSystemTest.OpenDirectoryAsFileForRead` was
not updated to match, causing it to fail at the
`ASSERT_THAT_EXPECTED(FD, Succeeded())` assertion.

Add a `#elif defined(_AIX) || defined(__MVS__)` branch to the test that
expects the error to be returned from `openNativeFileForRead()` rather
than from `readNativeFile()`, consistent with the behavior introduced by
that commit.
https://invent.kde.org/qt/clang/llvm-project/-/commit/828d2d7fb65a9cd5946b347ad5173e3bdb21387d

Git commit 17c348dc5f44e22ce9f94e5301ad4a131d4b0e32 by GitHub (on behalf of Macro Terra) on 14/08/2026 at 15:44..
[clang][Tooling] Ignore end-of-directive tokens in TokenCollector (#212242)

fixes #197652
### Summary

`TokenCollector` receives `tok::eod` from the preprocessor for an
end-of-directive marker, but that token has no one-to-one raw spelling.
Recording it as an expanded token can therefore make the
expanded-to-spelled mapping fail in clangd.

Skip `tok::eod` alongside non-module annotation tokens. Keep the
existing `annot_module_name` reconstruction path, as it intentionally
supplies a spelling.

Add a regression test for:

```cpp
}
#pragma clang __debug dump
```

assisted by codex.
https://invent.kde.org/qt/clang/llvm-project/-/commit/17c348dc5f44e22ce9f94e5301ad4a131d4b0e32

Git commit e02aed68d725366625c76da93d265e0d58f261f9 by GitHub (on behalf of Kazu Hirata) on 14/08/2026 at 15:47..
[ADT] Add try_emplace and insert to SortedVectorMap (#216251)

This patch adds try_emplace and insert to SortedVectorMap.

try_emplace_impl serves as the common implementation for try_emplace,
insert, and operator[].

The motivation here is to support insert for the ongoing sample
profile loader/writer work.  We might also need try_emplace if we
clean up constructs like insert(std::make_pair(K, V)).

Assisted-by: Antigravity
https://invent.kde.org/qt/clang/llvm-project/-/commit/e02aed68d725366625c76da93d265e0d58f261f9

Git commit ec26997e2e4606d97918a4a082c4f93ca38a6f46 by GitHub (on behalf of Kazu Hirata) on 14/08/2026 at 15:47..
[GlobalISel] Remove dead declarations (#216267)

tryCombineShuffleVector: The corresponding function definition was
removed on May 20, 2026 in commit
376870209db2e3ad33b082f839a7899c2972cc93.

translateCallBrIntrinsic: Added on December 4, 2025 in commit
e84fdbe1ef09c7c1ed2fab688607cf4b406fb395 without a corresponding
function definition.

buildAtomicRMWUSubCond and buildAtomicRMWUSubSat: Added on September 6,
2024 in commit 4af249fe6e81abd137c95bc25f5060ae305134ca without
corresponding function definitions.
https://invent.kde.org/qt/clang/llvm-project/-/commit/ec26997e2e4606d97918a4a082c4f93ca38a6f46

Git commit 7e42b97db3c1b574dae3af4d82bb48676bd5005f by GitHub (on behalf of Zeyi Xu) on 14/08/2026 at 16:04..
[Tooling] Resolve tool names from PATH in CommonOptionsParser (#213681)

Resolve tool names through `PATH` before passing compilation commands to
the Clang driver.

Compilation databases may specify the tool by name rather than by
absolute path:

e.g.
```json
[
  {
    "directory": "/path/to/project",
    "command": "clang -c test.c",
    "file": "test.c"
  }
]
```

LibTooling invokes the driver in-process, so the compiler name in the
example is not resolved by a shell. As a result, the driver can't find
installation-relative resources.

This could be problematic with Homebrew Clang, where the missing
executable path prevents the driver from loading the SDK configuration
and causes system headers to be unavailable.

Closes #213633
https://invent.kde.org/qt/clang/llvm-project/-/commit/7e42b97db3c1b574dae3af4d82bb48676bd5005f

Git commit 1cb219f75aaeb7c2b98d85ec87d92d3c602b7a78 by GitHub (on behalf of original-cooling-space) on 14/08/2026 at 16:07..
[libc][math] Fix -Wc++23-extensions warnings in erfcf16 and erff16. (#215613)

Change the original logic which directly returns a fixed value to use
`fputil::cast` for the calculation.

## Problem Description  
I encountered this issue while debugging the `llvm-mc` module. When I
was running `ninja -C build llvm-mc`, During compilation, the terminal
displayed the warning `-Wc++23-extensions warnings`.

## Solution  
I replaced the original code, which looked something like this, with the
following method:
  
```h
// before
return 0.0f16;

// The original approach
return fputil::cast<float16>(0.0f);

// Intue suggested
FPBits::zero().get_val();
```

The conditional expression uses `constexpr float16` to store the result
in a variable for processing.

## Test case  
I added two additional tests to the two files.  

- `‎libc/src/__support/math/erfcf16.h‎`
- `‎libc/src/__support/math/erff16.h‎`

0ne is for test cases greater than 2.0 and another to test cases less
than 1.0. This test also added test cases with negative values. I ran
the tests using `ninja -C build llvm-lit`.
https://invent.kde.org/qt/clang/llvm-project/-/commit/1cb219f75aaeb7c2b98d85ec87d92d3c602b7a78

Git commit 1f4574c6033cae84c88ca69bb2b73c9b029925e3 by GitHub (on behalf of Walter Lee) on 14/08/2026 at 16:09..
[bazel][libc] Remove LIBC_FULL_BUILD-only dependencies (#216345)

Fixes 45f1b25a0d069a2cee0632e1d1df4ff3342f136e.

Our BUILD files don't support LIBC_FULL_BUILD yet. Adding these
dependencies cause issues with darwin_x86_64 builds, etc.
https://invent.kde.org/qt/clang/llvm-project/-/commit/1f4574c6033cae84c88ca69bb2b73c9b029925e3

Git commit 49892f2014aa73f30fcbfce6ea0100235de82d9b by GitHub (on behalf of Sophia Herrmann) on 14/08/2026 at 16:13..
[Offload] Add GetErrorName and GetErrorString to LLVMOffloadKernel (#212887)

Continuing the work to cover cuda/hip runtime in LLVMOffloadKernel, this
PR introduces the `GetErrorName` and `GetErrorString` functions for
pretty printing LLVMOffload errors, in a separate `LanguageUtils.cpp`

Additionally moves out helper functions ` convertResult` and
`getQueueFromStream` into the utils file too.

Assisted by GPT-5.5, checked and reviewed manually
https://invent.kde.org/qt/clang/llvm-project/-/commit/49892f2014aa73f30fcbfce6ea0100235de82d9b

Git commit ea051fd558d94cd08348834ebecac4af231efeda by GitHub (on behalf of Jonas Devlieghere) on 14/08/2026 at 16:21..
[lldb] Search for a corefile's images before loading any of them (#215393)

A userland or kernel corefile can list hundreds of images, and searching for
one can shell out to a symbol server or fetch over the network. Searching for
them one at a time is where loading such a corefile spends its time.

Add a batch form of SymbolLocator::Locate that runs the searches on the
debugger's thread pool, gated on target.parallel-module-load. Results come
back in the order the requests were given, since that order decides the
Target's module order. Only the results are ordered, and anything a search
reports to the user arrives in whatever order the searches finish in.

Only the plugin searches run concurrently, so a platform hook does not have to
be thread safe to take part, and reading a binary's UUID out of memory stays
on the calling thread.

Setting up a platform binary can replace the Target's platform and dynamic
loader, and now happens for every image before any of them is searched for, so
the platform a corefile asks for is the one all of its images are searched
with. Previously the images listed ahead of a platform binary were searched
with whatever platform preceded it.

Assisted-by: Claude
https://invent.kde.org/qt/clang/llvm-project/-/commit/ea051fd558d94cd08348834ebecac4af231efeda

Git commit 6f59d5df7fc1a15e4e499f3ee3fe2c4e6f973f3b by GitHub (on behalf of Amr Hesham) on 14/08/2026 at 16:23..
[CIR] Support vector of bool with padding (#215850)

Support the vector of bool emit from and to memory with padding
https://invent.kde.org/qt/clang/llvm-project/-/commit/6f59d5df7fc1a15e4e499f3ee3fe2c4e6f973f3b

Git commit a5f4c6eda314180dd07241514a9d4bdf22fa2a2d by GitHub (on behalf of Matt Arsenault) on 14/08/2026 at 16:27..
MachineRegisterInfo: Mark getVRegDef/getUniqueVRegDef LLVM_READONLY (#216335)

Both queries only read the use-def lists and have no side effects, so
annotate them pure which enables CSE.

GlobalISel spams a lot of these calls, and some code cleanups are
likely to increase this spam.
https://invent.kde.org/qt/clang/llvm-project/-/commit/a5f4c6eda314180dd07241514a9d4bdf22fa2a2d

Git commit aee8caff2c22194a7aae7ade5319a8d53c8cba97 by GitHub (on behalf of Alex Duran) on 14/08/2026 at 16:29..
[clang][sema] Suppress unsupported 128-bit mode attribute diagnostic for OpenMP device compilation (#214497)

On systems with newer glibc (2.41) when compiling with -fopenmp-targets
the device compilation side fails with:

> /usr/include/x86_64-linux-gnu/bits/floatn.h:83:52: error: unsupported
machine mode '__TC__'
> 83 | typedef _Complex float __cfloat128 __attribute__ ((__mode__
(__TC__)));
>           |                                                    ^
 
Sema::AddModeAttr already avoids diagnosing a 128-bit `mode` attribute
(e.g. __TC__, as used by glibc's __cfloat128) that the target can't
represent, but only for CUDA and SYCL device compilation. OpenMP
target-device compilation for targets also lacks a 128-bit float/complex
representation so we extend the check to cover OpenMPIsTargetDevice as
well to avoid the fail.

Assisted by Claude.
https://invent.kde.org/qt/clang/llvm-project/-/commit/aee8caff2c22194a7aae7ade5319a8d53c8cba97

Git commit 3267c0b4d9263abf2290aa96f6eee37def9b0bc7 by GitHub (on behalf of Craig Topper) on 14/08/2026 at 16:38..
[DAGCombiner] Remove unnecessary N0->hasOneUse() check from foldSelectOfBinops. NFC (#216221)

The TODO suggests this might cause an infinite loop, but it does not
show up in any lit tests.

The TODO was added by Sanjay Patel in 2021 in 985b48f183410
https://invent.kde.org/qt/clang/llvm-project/-/commit/3267c0b4d9263abf2290aa96f6eee37def9b0bc7

Git commit afd28e2bfdb941618ff7827aae3a283a4d0d9f1f by GitHub (on behalf of Schrodinger ZHU Yifan) on 14/08/2026 at 16:40..
[libc] Implement TLSF FreeStore with Trie Overflow Bin (#203415)

This PR replaces the old single-Trie allocator in LLVM libc with a
Two-Level Segregated Fit (TLSF) allocator, optimized to use FreeTrie
only for the overflow bin when user opt-in.

TLSF generally provides constant overhead on fast paths. However, notice
that during the fallback routine, TLSF will need to do a linear search,
which, in the worst case, can lead to O(`#alloc`) overhead. Hence, for
large allocations, keeping a freetrie can avoid fragmentation and
accidental large latency.

To make a heap fully configurable, we may also allow the using freetrie
for inner nodes of the TLSF table; which give even stricter
"constant-time" allocation for hard reatime with larger overhead.
However, I currently don't have enough benchmark data in hands; so I
separate out those changes to a separate patch.

~~Needs to be rebased after
https://github.com/llvm/llvm-project/pull/203351 landed.~~

Assisted-by: Gemini powered automation tools (human-in-the-loop)
https://invent.kde.org/qt/clang/llvm-project/-/commit/afd28e2bfdb941618ff7827aae3a283a4d0d9f1f

Git commit e443129437729db6d4ab76201130bc915f762bed by GitHub (on behalf of Nick Sarnie) on 14/08/2026 at 16:44..
[libsycl][unit] Use mock dummy handle functions for olMemAlloc functions (#216341)

Review feedback from https://github.com/llvm/llvm-project/pull/216170.

Signed-off-by: Nick Sarnie <[email protected]>
https://invent.kde.org/qt/clang/llvm-project/-/commit/e443129437729db6d4ab76201130bc915f762bed

Git commit bc6c2af342f5cd1905c18be05fd391e44b12ea1f by GitHub (on behalf of Bar Soloveychik) on 14/08/2026 at 16:49..
[lldb] Cache register types by object UID and register size (#215874)

XML type IDs are only unique within a feature, so they cannot identify
entries in the target-wide `CompilerType` cache. Assign each
`RegisterType` a lifetime-unique UID and combine it with the register
size for cache keys. This also prevents a new process from aliasing
stale entries when an allocator reuses a RegisterType address.

Insert completed enum and flags types into the cache, and clear cached
CompilerTypes when the target replaces its scratch `TypeSystemClang`.
Add direct builder tests for cache reuse, same-ID definitions,
size-sensitive enums, object-address reuse, and scratch type-system
replacement.

---------

Co-authored-by: Bar Soloveychik <[email protected]>
Co-authored-by: David Spickett <[email protected]>
https://invent.kde.org/qt/clang/llvm-project/-/commit/bc6c2af342f5cd1905c18be05fd391e44b12ea1f

Git commit 4cc02503f584aad493a1d0d35bb5afb710a5510b by GitHub (on behalf of Abid Qadeer) on 14/08/2026 at 16:50..
[flang][debug] Emit imported entities in source order (#215845)

The entities a USE statement brings into a scope were gathered in a
`DenseSet`, so they reached the subprogram's retained nodes in an order
that follows pointer values. Compiling the same file twice therefore
produced different debug information and a different object file, which
is enough to break a reproducible build.

Use a `SetVector` instead. It keeps the deduplication the code relies on
and hands the entities back in the order they were created, which is the
order they appear in the source.

Fixes https://github.com/llvm/llvm-project/issues/215827

Co-authored-by: Cursor <[email protected]>
https://invent.kde.org/qt/clang/llvm-project/-/commit/4cc02503f584aad493a1d0d35bb5afb710a5510b

Git commit 8873c2986bae2b6bf34a382c27467a528c5fe4e0 by GitHub (on behalf of Augusto Noronha) on 14/08/2026 at 17:05..
[lldb][test] Don't let the Darwin builder clobber ARCH_CFLAGS (#215655)

f5e2b8b1df07 ("[lldb] Rally around triple rather than arch in the API
tests") moved the construction of ARCH_CFLAGS into Makefile.rules but
left the builder returning a value. Configurations whose triple names a
bare darwin OS take an early return and are unaffected, which is why a
default macOS build does not notice.

Assisted-by: claude
https://invent.kde.org/qt/clang/llvm-project/-/commit/8873c2986bae2b6bf34a382c27467a528c5fe4e0

Git commit cca9b1331372eadf57b66d50ee69c45d9bb2973f by GitHub (on behalf of Joseph Huber) on 14/08/2026 at 17:06..
[LinkerWrapper] Fix search paths for Windows link style invocations (#216239)

Summary:
The windows link patterns were slightly wrong because `foo.lib` on the
command line as an input implies searching. We track this for the
`-libpath` argument and search them now as the linker would.
Additionally, fixes a problem with whole-archive not being handled
properly.
https://invent.kde.org/qt/clang/llvm-project/-/commit/cca9b1331372eadf57b66d50ee69c45d9bb2973f

Git commit 4cac4bbb55ad7b3a5d6601f56a8f55a16c3d074f by GitHub (on behalf of Walter Lee) on 14/08/2026 at 17:07..
[bazel][libc] Temporarily disable full_build include tests (#216359)

They are currently broken due to

https://github.com/llvm/llvm-project/commit/1f4574c6033cae84c88ca69bb2b73c9b029925e3.
We need a few hours to resolve it, and we're using this to unblock our
CI.
https://invent.kde.org/qt/clang/llvm-project/-/commit/4cac4bbb55ad7b3a5d6601f56a8f55a16c3d074f

Git commit a26fae565bbca5229558bb7488dfc895e803124b by GitHub (on behalf of Shilei Tian) on 14/08/2026 at 17:25..
[AMDGPU][MC] Check lit64 availability because decode (#214976)

Fixes #214953.
https://invent.kde.org/qt/clang/llvm-project/-/commit/a26fae565bbca5229558bb7488dfc895e803124b

Git commit b2bb415e3f58a1e965e80e35b1f4647fbd44188a by GitHub (on behalf of Walter Lee) on 14/08/2026 at 17:28..
[bazel][libc] Temporarily disable full_build include tests (cont.) (#216366)

Fix #216359.  Sorry about that.
https://invent.kde.org/qt/clang/llvm-project/-/commit/b2bb415e3f58a1e965e80e35b1f4647fbd44188a

Git commit b7d3cee21be43bd6969764c2038ab72d49ea0b1f by GitHub (on behalf of ShashwathiNavada) on 14/08/2026 at 17:33..
[Flang][OpenMP] Support certain directives in PURE procedures (#212676)

Add compiler support for directive restrictions in PURE procedures,
permitting only those directives that have a "pure" property, including:
metadirecitve, assume and assumes, nothing, error, and loop-transforming
directives.
https://invent.kde.org/qt/clang/llvm-project/-/commit/b7d3cee21be43bd6969764c2038ab72d49ea0b1f

Git commit aa8bf3135b46765ada6759a053c33b8c17844a91 by GitHub (on behalf of Sophia Herrmann) on 14/08/2026 at 17:37..
[LLVMOffload] Add more error types + GetLastError/PeekAtLastError (#213389)

This PR expands LLVMOffloadKernel's error types with
`ErrorInvalidResourceHandle` and `ErrorInvalidConfiguration`.
It also adds a language local, thread local LastError which can be
read/retrieved with `PeekAtLastError`/`GetLastError` respectively. Tests
are in #213390

Assisted by GPT-5.5, checked and reviewed manually
https://invent.kde.org/qt/clang/llvm-project/-/commit/aa8bf3135b46765ada6759a053c33b8c17844a91

Git commit eb079b0b1cbbb85265fd096f7c2ef2bb89637904 by GitHub (on behalf of Ebuka Ezike) on 14/08/2026 at 17:48..
[lldb] Indent Watchpoint's new value correctly. (#216351)

Previously
```
Watchpoint 1 hit:
    old value: 2
new value: 4
```
Now
```
Watchpoint 1 hit:
    old value: 2
    new value: 4
```
https://invent.kde.org/qt/clang/llvm-project/-/commit/eb079b0b1cbbb85265fd096f7c2ef2bb89637904

Git commit 745e577934311d7006a207105697c8f3379ca4fa by GitHub (on behalf of Alex MacLean) on 14/08/2026 at 17:50..
[SlotIndexes] Use analysis block numbers (NFC) (#215171)
https://invent.kde.org/qt/clang/llvm-project/-/commit/745e577934311d7006a207105697c8f3379ca4fa

Git commit 6edb8cf11b352ad10885cfbece0ef6057ae327e4 by GitHub (on behalf of Valery Dmitriev) on 14/08/2026 at 17:56..
[flang] ieee intrinsics shall preserve NaN semantics. (#215928)

The following motivating test case:
```fortran
Program repro
  Use Ieee_Arithmetic
  Real nan
  nan = Ieee_Value(nan,Ieee_Quiet_NaN)
  Call test(1.0,nan)
  Call test(nan,1.0)
  Call test(nan,-1.0)
Contains
  Subroutine test(a,b)
    Real x
    x = Ieee_Min_Num_Mag(a,b)
    Print *,'x=', x
  End Subroutine test
End Program
```
even with -Ofast [-O3 -ffast-math] is not expected to print NaN, but it
does. That happens basically due to attaching fast math flags to the
intrinsic lowering code that set incorrect assumptions about operand
values and lead to improper optimizations. Hence the solution is exactly
to strip the flags when lowering ieee intrinsics. The patch strips all
the fast math flags except 'contract' to minimize impact on some
existing tests for a few ieee intrinsics. The flag is considered benign.

Assisted-by: Claude
Assisted-by: Grok
https://invent.kde.org/qt/clang/llvm-project/-/commit/6edb8cf11b352ad10885cfbece0ef6057ae327e4

Git commit 08e48243b19ded3f9423913c1e0b274a3472358a by GitHub (on behalf of Donát Nagy) on 14/08/2026 at 18:08..
[analyzer] Fix timing of `PostStmt<CXXDeleteExpr>` (#215828)

When `ExprEngine::Visit` visits a statement, it usually first invokes
the `PreStmt` callbacks, then performs the statement-specific visitation
logic, then finally invokes the `PostStmt` callbacks.

Before this commit, `CXXDeleteExpr` did not follow this regular pattern,
because it invoked the `PostStmt` callbacks before the
statement-specific logic. This exceptional logic was introduced in 2020
by commit 9d69072fb80755a0029a01c74892b4bf03f20f65 and I confirmed with
the author of that commit that the unusual order is not intentional.

This commit ensures that `CXXDeleteExpr` also follows the standard order
by swapping the `PostStmt` step and the `VisitCXXDeleteExpr()` call.

As no (upstream) checkers use the `PostStmt<CXXDeleteExpr>` callback,
this is -- in practice -- a non-functional change. (The inconsistency
was spotted by Gábor Tóthvári in the source code.)
https://invent.kde.org/qt/clang/llvm-project/-/commit/08e48243b19ded3f9423913c1e0b274a3472358a

Git commit 10b4fa5b79eb9d27b4928ad82afa3847762bc72f by GitHub (on behalf of Arron Zou) on 14/08/2026 at 18:16..
[InstCombine] Don't assert on samesign ule/uge of sext (#216079)

`foldICmpWithZextOrSext` asserted leftover unsigned icmp of `sext` vs an
unrepresentable constant was `ugt`. `icmp samesign ule/uge` is not
always canonicalized to `ult/ugt`.

Fold these in InstSimplify by converting samesign unsigned predicates to
signed ones with `getPreferredSignedPredicate()`.

Fixes #216058

AI tool usage: an AI coding assistant helped write the tests and iterate
on the InstSimplify fold.
https://invent.kde.org/qt/clang/llvm-project/-/commit/10b4fa5b79eb9d27b4928ad82afa3847762bc72f

Git commit 83164eabcad5ec17eb0f4197272e00bce48bd1ca by GitHub (on behalf of qyingwu) on 14/08/2026 at 18:27..
[mlir][AMDGPU] Diagnose unsupported packed fp8 conversions (#210565)

## Summary

Fixes #210266.

`amdgpu.packed_trunc_2xfp8` could crash during AMDGPU-to-ROCDL
conversion when the result
element type does not match the selected chipset. For example, `gfx942`
expects FNUZ fp8
types, but the reproducer uses the OCP `f8E4M3FN` type. The lowering
failed to create an
intrinsic result and later tried to bitcast a null value.

This patch diagnoses unsupported packed fp8 conversions instead of
crashing. It also adds
the same guard for `amdgpu.packed_stoch_round_fp8`, which had the same
unchecked result
path.
https://invent.kde.org/qt/clang/llvm-project/-/commit/83164eabcad5ec17eb0f4197272e00bce48bd1ca

Git commit 9223dc8b71d11798656fc5fbac507118881632bc by GitHub (on behalf of Fady Farag) on 14/08/2026 at 18:29..
[webkit.UncountedLambdaCapturesChecker] Look through inline namespaces when recognizing std::ranges algorithms (#216229)

shouldTreatAllArgAsNoEscape() matches the callee's parent declarations
against the literal pair std -> ranges, so the exemption for std::ranges
algorithms never fires with libc++, where the path is std::__1::ranges
due to the versioning inline namespace. Existing tests pass because they
mock std::ranges without an inline namespace. This skips inline
namespaces in the parent walk, matching actual libc++ shape.
https://invent.kde.org/qt/clang/llvm-project/-/commit/9223dc8b71d11798656fc5fbac507118881632bc

Git commit ab306f21e79223e1d5ee56674af151cd9fbebd71 by GitHub (on behalf of Tejas Joshi) on 14/08/2026 at 18:33..
[AA] Add RunEarly support to createExternalAAWrapperPass (#214365)

Earlier changes introduced RunEarly to control running external AA
passes early/late. Though, it missed to allow registering similarly
through createExternalAAWrapperPass API, the patch allows the same. This
does break ABI compatibility but having two seems overkill for legacy
PM.
https://invent.kde.org/qt/clang/llvm-project/-/commit/ab306f21e79223e1d5ee56674af151cd9fbebd71

Git commit 16a8d8d038a39ba59fc36962088ad8afb91007a5 by GitHub (on behalf of Matt Arsenault) on 14/08/2026 at 18:37..
RuntimeLibcalls: Fix reporting incorrectly typed fp128 long double functions (#214944)
https://invent.kde.org/qt/clang/llvm-project/-/commit/16a8d8d038a39ba59fc36962088ad8afb91007a5

Git commit 6d9cbf4b6c5b79928bf1d3ada10e67e06e4c3953 by GitHub (on behalf of Mehdi Amini) on 14/08/2026 at 19:09..
[MLIR][ODS] Add strict property assembly format mode (#196269)

Introduce a dialect-level ODS flag for strict property handling in
declarative assembly formats. It is disabled by default for now,
preserving existing parser behavior unless a dialect opts in.

Enable the mode immediately for dialects whose declarative assembly
formats already satisfy these binding rules.

When enabled, a property-backed op format must bind every inherent
attribute and property directly or include prop-dict.

Generated parsers for opted-in dialects also reject inherent attributes
that arrive through attr-dict, preventing Operation::setAttrs from
populating properties through that path.

Add mlir-tblgen coverage and document default and strict dialect
behavior.

Assisted-by: Codex
https://invent.kde.org/qt/clang/llvm-project/-/commit/6d9cbf4b6c5b79928bf1d3ada10e67e06e4c3953

Git commit bf88636fa3f4b1dabf86c60b04176f0ee2b3e887 by GitHub (on behalf of Marc Auberer) on 14/08/2026 at 19:09..
[ADT] Remove deprecated is and get functions on PointerUnion (#216364)

Remove deprecated is and get functions in favor of llvm::{isa,cast}.
There are no more remaining in-tree users.
https://invent.kde.org/qt/clang/llvm-project/-/commit/bf88636fa3f4b1dabf86c60b04176f0ee2b3e887

Git commit 2336d2cec6b4845691251869ebc1442595008a60 by GitHub (on behalf of eleviant) on 14/08/2026 at 19:13..
[clang] Allow C-style casts in constexpr in MS compatible mode (#197005)

Patch allows folding constant expression containing C-style cast and/or
taking field address of a null pointer when -fms-compatibility is given.
This allows using offsetof-like macros in constant expressions when
compiling legacy Windows code.
https://invent.kde.org/qt/clang/llvm-project/-/commit/2336d2cec6b4845691251869ebc1442595008a60

Git commit e803069070cf5f55d9c4b9f2e07a1139bb8ec56b by GitHub (on behalf of Mehdi Amini) on 14/08/2026 at 19:13..
[mlir][AffineExpr] Fix UBSan signed-integer overflow in subtraction operators (#186155)

`AffineExpr::operator-(int64_t)` was negating the value with unary `-`,
which is undefined behavior for INT64_MIN. Similarly,
`AffineExpr::operator-(AffineExpr)` called unary `operator-()` on a
constant AffineExpr, which multiplies by -1 — also overflowing for
INT64_MIN.

Fix both by using unsigned arithmetic for the negation:
- `operator-(int64_t)` now casts to `uint64_t` before negating.
- `operator-(AffineExpr)` short-circuits constant RHS through
  `operator-(int64_t)` instead of the multiply-by-(-1) path.

This correctly round-trips affine maps like `d0 - 9223372036854775808`
(printed for `d0 + INT64_MIN`) and fixes any other callers that subtract
a constant expression equal to INT64_MIN.

Fixes #162774

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

Git commit 4fe56282ed2aab87bc9a2e3358046f3d0dccd48f by GitHub (on behalf of Amr Hesham) on 14/08/2026 at 19:17..
[CIR] Support Const vector of bool (#216133)

Support lowering the constant vector of booleans as an element type
https://invent.kde.org/qt/clang/llvm-project/-/commit/4fe56282ed2aab87bc9a2e3358046f3d0dccd48f

Git commit 70eaedc3173dfd86fa8326bf041fc9f8857c46c4 by GitHub (on behalf of Zachary Yedidia) on 14/08/2026 at 19:18..
[NFC][X86] Remove CurOp parameter from emitPrefixImpl (#215038)

Follow-up to #211685 that resolves a pre-existing issue found there,
where the body of `emitPrefixImpl` relies on the caller passing the
result of `getOperandBias` to it as `CurOp`. This refactors the function
to not take a `CurOp` at all, and do all the `CurOp` movement in the
caller (`encodeInstruction`) instead
https://invent.kde.org/qt/clang/llvm-project/-/commit/70eaedc3173dfd86fa8326bf041fc9f8857c46c4

Git commit aa4fe5febacba53ae348ff2457648319b3d25da5 by GitHub (on behalf of Mehdi Amini) on 14/08/2026 at 19:32..
[MLIR][ControlFlow] Enable strict property assembly format (#196280)

Enable the strict properties assembly format mode for the ControlFlow
dialect. The dialect formats already cover their inherent attributes,
except for a test that still used attr-dict spelling for branch weights.

Update that test to use the existing weights(...) syntax so the inherent
attribute is parsed through the declarative format.

Assisted-by: Codex
https://invent.kde.org/qt/clang/llvm-project/-/commit/aa4fe5febacba53ae348ff2457648319b3d25da5

Git commit 587241c54f25ca0dac2c283f1b6be9015b38c6c7 by GitHub (on behalf of Mehdi Amini) on 14/08/2026 at 19:32..
[MLIR][Rewrite] Support unqualified pattern names in disable/enable-patterns (#188988)

FrozenRewritePatternSet previously required exact string matching for
disable-patterns and enable-patterns filter options. Pattern debug names
are auto-generated as fully qualified typenames (e.g., "(anonymous
namespace)::FooBar"), but users often want to filter by just the class
name (e.g., "FooBar").

This change adds support for unqualified name matching: if a
user-supplied filter label contains no "::", it is also matched against
the unqualified part of the pattern debug name (the suffix after the
last "::"). Labels containing "::" still require exact matching as
before.

A new test exercises disable/enable filtering by unqualified name for a
pattern living in an anonymous namespace.

Fixes #120489

Assisted-by: Claude Code
https://invent.kde.org/qt/clang/llvm-project/-/commit/587241c54f25ca0dac2c283f1b6be9015b38c6c7

Git commit 2e172cd38272124da30cc913f1a372ba9ea59dcf by GitHub (on behalf of Matt Arsenault) on 14/08/2026 at 19:42..
GlobalISel: Use MIPatternMatch to look up defs in the artifact combiner (#216358)
https://invent.kde.org/qt/clang/llvm-project/-/commit/2e172cd38272124da30cc913f1a372ba9ea59dcf

Git commit ce7c9ad456480a9e097574f100fe5774a7ad4aad by GitHub (on behalf of Dmitry Sidorov) on 14/08/2026 at 19:43..
[GlobalISel] Propagate fast-math flags when fusing fmul+fadd into fma (#215150)
https://invent.kde.org/qt/clang/llvm-project/-/commit/ce7c9ad456480a9e097574f100fe5774a7ad4aad

Git commit 55bed95c3eda6a0588151ecad62dc36cb29b8c82 by GitHub (on behalf of Mehdi Amini) on 14/08/2026 at 20:03..
[MLIR][SPIRV] Enable strict property assembly format (#196282)

Enable strict property assembly format mode for SPIR-V and add property
dictionaries to declarative formats that still carry inherent attributes
outside explicit operands or clauses.

Refresh ARM graph and TOSA tests so GraphConstant uses prop-dict
spelling for its inherent constant identifier.

Assisted-by: Codex
https://invent.kde.org/qt/clang/llvm-project/-/commit/55bed95c3eda6a0588151ecad62dc36cb29b8c82

Git commit 4ebdce437b04793d0bc4318b50a9f8278113a59c by GitHub (on behalf of Jinsong Ji) on 14/08/2026 at 20:07..
[NFC] Remove obsolete typeids.test after fa23198d685b (#216379)

fa23198d685b replaced llvm::Any with IRUnitRef in
PassInstrumentation. IRUnitRef uses an enum discriminator instead of
address-based TypeId, so the visibility guard this test enforced no
longer applies.
https://invent.kde.org/qt/clang/llvm-project/-/commit/4ebdce437b04793d0bc4318b50a9f8278113a59c

Git commit cc6f1115b0e913f020ea815c17f2f3cd2605aa50 by GitHub (on behalf of Kazu Hirata) on 14/08/2026 at 20:17..
[ProfileData] Remove toCompress and setToCompress from ProfileSymbolList (NFC) (#216236)

This patch removes toCompress, setToCompress, and ToCompress in
ProfileSymbolList.  Nobody calls setToCompress, so ToCompress is
always false.
https://invent.kde.org/qt/clang/llvm-project/-/commit/cc6f1115b0e913f020ea815c17f2f3cd2605aa50

Git commit 8f61453cdf79d28e79964197ad865276182cacf1 by GitHub (on behalf of Folkert de Vries) on 14/08/2026 at 20:40..
[RISCV][NFC] add `_Complex {integer}` ABI tests (#216386)

based on https://github.com/llvm/llvm-project/pull/215222, RISCV has the
same bug.

The fix is basically identical, I'll put up a PR once this merges.
https://invent.kde.org/qt/clang/llvm-project/-/commit/8f61453cdf79d28e79964197ad865276182cacf1

Git commit fc145527a539be71d15fca3bc10618196e84f4cf by GitHub (on behalf of Adrian Prantl) on 14/08/2026 at 20:43..
[lldb][CMake] Give the staged lldb-defines.h a build rule (#216394)

a05b232076ed dropped lldb-defines.h from the header staging loop so that
the source header is never copied, leaving the staged copy to be
produced by a POST_BUILD command on liblldb-header-staging. Ninja cannot
see files produced that way, and LLDBRPCHeaders.cmake depends on the
staged path directly, so a clean build with LLDB_BUILD_LLDBRPC enabled
fails to even load the graph:

  ninja: error: 'include/lldb/lldb-defines.h', needed by
  'tools/lldb-rpc/DerivedHeaders/lldb-rpc-defines.h', missing and no
  known rule to make it

Dropping the header from the loop also removed it from
lldb_staged_headers and from LLDB.framework/Headers, even though
SBDefines.h includes it.

Stage the header through version-header-fix.py from inside the loop
instead. The script reads the source header and writes a fresh staged
copy, so the source tree can still be read-only, and the staged header
gets a rule that dependents can rely on.

Assisted-by: Claude
https://invent.kde.org/qt/clang/llvm-project/-/commit/fc145527a539be71d15fca3bc10618196e84f4cf

Git commit 048fb2887d4ab0f4c6e71667337bba70704908b4 by GitHub (on behalf of Nerixyz) on 14/08/2026 at 20:46..
[lldb] Disable C4250 warning on MSVC (#215304)

When compiling LLDB with MSVC, there are a lot of
[C4250](https://learn.microsoft.com/en-us/cpp/error-messages/compiler-warnings/compiler-warning-level-2-c4250)
warnings (A inherits B::func via dominance). One for every subclass of
`ScriptedPythonInterface`. This PR disables the warning on MSVC.
https://invent.kde.org/qt/clang/llvm-project/-/commit/048fb2887d4ab0f4c6e71667337bba70704908b4

Git commit 99690a356c8c059db73786adecd827d7f20e3297 by GitHub (on behalf of Adrian Prantl) on 14/08/2026 at 20:49..
[LLDB] Remove fallthrough (#216398)

Address post-commit feedback on
https://github.com/llvm/llvm-project/commit/8ad0f7cf78f12b51e91d3799593a1d766b6ab6a6.
https://invent.kde.org/qt/clang/llvm-project/-/commit/99690a356c8c059db73786adecd827d7f20e3297

Git commit cf98a4bf35f296f734b3a6ba3202baf468386c51 by GitHub (on behalf of Florian Hahn) on 14/08/2026 at 20:52..
[LV] Simplify the latch branch before rewriting ALM for a scalar VF (#216257)

Run simplifyBranchConditionForVFAndUF before replaceMaskWithCompare
before, so the simplification triggers before replaceMaskWithCompare
writes the plan.

PR: https://github.com/llvm/llvm-project/pull/216257
https://invent.kde.org/qt/clang/llvm-project/-/commit/cf98a4bf35f296f734b3a6ba3202baf468386c51

Git commit 5e8490a1cf89bd94194246d0569c232a923d0161 by GitHub (on behalf of Jonas Devlieghere) on 14/08/2026 at 20:59..
[DWARFLinker] Constrain a function's high_pc to its own symbol (#215952)

Mach-O objects built with .subsections_via_symbols make every symbol an
independently placeable atom, and the linker packs atoms without
preserving the spacing they had in the object file.

I have an example where the compiler describes such a subprogram as
extending past its own atom. While it's debatable whether that's a good
idea, it's not invalid in the object file. However, once linked, it is
invalid.

We can make dsymutil resilient against this by looking at the size of
the symbol in the debug map and adjusting the end_pc. I'm doing so
conservatively so that only a collision is repaired. Already
overlapping/invalid ranges remain untouched.

rdar://184768778
https://invent.kde.org/qt/clang/llvm-project/-/commit/5e8490a1cf89bd94194246d0569c232a923d0161

Git commit 947565abdecf1e5f29e70bdb2bbfd8bc4de564fa by GitHub (on behalf of Farzon Lotfi) on 14/08/2026 at 21:15..
[HLSL][longvec][Tablegen] Use templates to define Vector api's larger than 4 (#216143)

resolves #216139
resolves #216140

This change adds a templatized vector emitter to TableGen's HLSLEmitter.
We add tests for the tablegen and confirm we did it right by
implementing the abs api.

Assisted by GPT-5.6 sol via co-pilot
https://invent.kde.org/qt/clang/llvm-project/-/commit/947565abdecf1e5f29e70bdb2bbfd8bc4de564fa

Git commit bfbac546e3b0245c404b7bb36f728dd238fb03e4 by GitHub (on behalf of Benedek Kaibas) on 14/08/2026 at 21:16..
[analyzer] Only underline the exact parameter that is bound to the return value in UseAfterLifetimeEnd (#215651)

Currently the `UseAfterLifetimeEnd` checker highlights always the first
argument that is annotated with the `[[clang::lifetimebound]]`
annotation. Like:
```text
temp.cpp:5:31: note: Value's lifetime bound to the lifetime of 'y' here
    4 |   int x = 1, y = 2;
      |   ~~~~~~~~~~~~~~~~
    5 |   return multi_param_test_ref(x, y);
      |                               ^
```

As seen even when checker correctly notes that the value's lifetime is
bound to the lifetime of the `y` parameter, it incorrectly highlights x
since that is the first annotated parameter. In order to fix this I have
added a logic which checks which annotated parameter's region is bound
to the return's region and do the highlight based on that.

This PR is part of stacked PRs that are improving the quality of the
emitted report of the `UseAfterLifetimeEnd` checker. The initial PR is
#215409

In a follow up PR I will fix the highlighting range of the variables,
from:

```text
    4 |   int x = 1, y = 2;
      |   ~~~~~~~~~~~~~~~~
```

to:
```text
    4 |   int x = 1, y = 2;
      |             ~~~~~~~
```
https://invent.kde.org/qt/clang/llvm-project/-/commit/bfbac546e3b0245c404b7bb36f728dd238fb03e4

Git commit 5122b087d2738a3ce747d5b02ecad52488ec600a by GitHub (on behalf of Sam Clegg) on 14/08/2026 at 21:30..
[clang][WebAssembly] Remove `OPT_no_pthread` handling (#216378)

`-no-pthread` was originally added to Clang in 425b1a5106def (D11087)
simply to prevent "unknown argument" errors when building winpthreads in
mingw-w64.

It was subsequently used in `WebAssembly.cpp` when thread options were
made consistent in 9d5a089bf544e (D57874) via `Args.hasFlag`.

No other Clang toolchains handle `OPT_no_pthread` (they all use
`Args.hasArg(options::OPT_pthread)`), and `-pthread` is not typically
treated as a negatable boolean option in GCC/Clang drivers.

Align WebAssembly with all other Clang toolchains by removing the
`OPT_no_pthread` check.
https://invent.kde.org/qt/clang/llvm-project/-/commit/5122b087d2738a3ce747d5b02ecad52488ec600a

Git commit dd19d5210352f004758d0a877b396ea9f04cfd70 by GitHub (on behalf of Alexey Bataev) on 14/08/2026 at 21:48..
[SLP]Recalculate copyable-element deps after tree reordering

Reordering permutes the operand columns of the entries and may move an
operand between copyable-covered and plain edges, making the computed
dependency counts stale and tripping the unscheduled-deps assertion.

Reviewers: 

Pull Request: https://github.com/llvm/llvm-project/pull/216410
https://invent.kde.org/qt/clang/llvm-project/-/commit/dd19d5210352f004758d0a877b396ea9f04cfd70

Git commit f7bb0605d73c2bef79aa27ffa4bc58f4f1d73e78 by GitHub (on behalf of 陈子昂) on 14/08/2026 at 21:59..
[SelectionDAG] SimplifySetCC - Improve shifted range checks with add offsets (#207955)

SelectionDAG currently shrinks large unsigned compare immediates by
shifting the compare operand as a whole. For top-bit range checks that
have been canonicalized to `icmp ult (add x, C), Width`, this can
preserve the pre-shift add and lead to extra masks, zero-extends, or
large immediates.

When the add offset and range width are aligned to the selected shift
and the original unsigned range does not wrap, move the offset after the
shift instead. This lets cases such as checking whether `x >> 48` is in
`[10, 20)` lower to shift/add/cmp.

Fixes #172674
https://invent.kde.org/qt/clang/llvm-project/-/commit/f7bb0605d73c2bef79aa27ffa4bc58f4f1d73e78

Git commit 12f8c22cdd235fe86c8a66f07a655fe9a080257d by GitHub (on behalf of Adam Smith) on 14/08/2026 at 22:05..
[CIR] Run callconv lowering in the tests that opted out of it (#216396)

48 CIR tests carried `-fno-clangir-call-conv-lowering` with a TODO to
drop it once the pass handled vector types, the long double wrapper,
f16, and f128. The classifier takes all of those now, so the opt-out and
its TODO go and the tests exercise the pass.

No CHECK line moves, so the IR these tests already pinned is what the
pass produces.

Assisted-by: Cursor / claude-opus-5
https://invent.kde.org/qt/clang/llvm-project/-/commit/12f8c22cdd235fe86c8a66f07a655fe9a080257d

Git commit 17bace69f10b8afaaec1568e239873ecdd736422 by GitHub (on behalf of Alexey Bataev) on 14/08/2026 at 22:06..
Revert "[SLP]Recalculate copyable-element deps after tree reordering"

This reverts commit dd19d5210352f004758d0a877b396ea9f04cfd70 to fix
buildbot https://lab.llvm.org/buildbot/#/builders/195/builds/29633

Reviewers: 

Pull Request: https://github.com/llvm/llvm-project/pull/216415
https://invent.kde.org/qt/clang/llvm-project/-/commit/17bace69f10b8afaaec1568e239873ecdd736422

Git commit bdedc49db2e53257b1c20aa410404ffe1674b80b by GitHub (on behalf of Dmitry Sidorov) on 14/08/2026 at 22:10..
[SLP] Account for fma fusion when vectorizing an ordered fadd reduction (#210399)

An ordered fadd reduction of contractable fmuls lowers to a chain of
fmas in scalar code. SLP vectorizes the fmul operand tree and leaves the
fadds as an ordered scalar chain, which breaks that fusion, but the
ordered-reduction cost path hardcodes ReductionCost = 0 and never
accounts for it. Change the fusion saving per reduced fmul so the cost
reflects the lost fusion.

The saving is zero on targets without a faster fma, so only targets that
actually fuse are affected.
https://invent.kde.org/qt/clang/llvm-project/-/commit/bdedc49db2e53257b1c20aa410404ffe1674b80b

Git commit 0522530de6a0cde22be74b9be9c2b40c708ac155 by GitHub (on behalf of Eric Christopher) on 14/08/2026 at 22:12..
Fix a typo in shorten-offset.ll (#216407)

Noticed by inspection "with by hand" -> "by hand."
https://invent.kde.org/qt/clang/llvm-project/-/commit/0522530de6a0cde22be74b9be9c2b40c708ac155

Git commit d6ea0866b832e40b8eaf297ea8fd3699b1bdfadc by GitHub (on behalf of Dmitry Sidorov) on 14/08/2026 at 22:14..
Revert "[SLP] Account for fma fusion when vectorizing an ordered fadd reduction" (#216416)

Reverts llvm/llvm-project#210399
https://invent.kde.org/qt/clang/llvm-project/-/commit/d6ea0866b832e40b8eaf297ea8fd3699b1bdfadc

Git commit 251ab4a3f2a2e0e8def833067064d5ad2b7efad9 by GitHub (on behalf of Med Ismail Bennani) on 14/08/2026 at 22:30..
[lldb] Wrap Target::GetAPIMutex() into a Lockable handle (NFC) (#212872)

While implementing #208242, we realized that we needed a Lockable
wrapper for the Target's API Mutex that could skip the locking on
re-entrant threads (when a command (i.e `bt`) triggers scripted
extension (i.e `ScriptedFrameProvider`) that uses SBAPI (i.e.
`SBFrame`), and still behave as a normal mutex otherwise. However, since
`Target::GetAPIMutex()` returns a `std::recursive_mutex&`, that can't
represent "no synchronization at all".

This is why this PR introduces `TargetAPILock`, a small Lockable type
that behaves exactly like `std::recursive_mutex`, with no RAII of its
own, so callers can wrap it in `std::lock_guard`/`std::unique_lock` like
they would any other Lockable.

A `TargetAPILock` is bound to a `Target` rather than to a specific
mutex, so `lock()`/`try_lock()` resolve which real mutex to use fresh on
every call instead of caching one resolution for the handle's lifetime.
`unlock()` replays whatever the matching `lock()`/`try_lock()` resolved
rather than re-resolving, so a policy change between the two calls can't
release the wrong mutex. That's also what lets a handle be constructed
on one thread and locked/unlocked on another, which the deferred-lock
`SBMutex` needs.

`GetAPIMutex()` now returns `TargetAPILock` by value, so every caller
that took its old `std::recursive_mutex&` materializes the handle into a
local and wraps that in a `lock_guard`/`unique_lock` instead. A few
places where the lock outlives its constructing statement
(`CommandObject`'s `m_api_locker`, `ValueLocker`,
`StoppedExecutionContext`) keep the resolved handle as a member and
release it explicitly instead.

`SBMutex`'s opaque member becomes a `std::variant<std::recursive_mutex,
TargetAPILock>` rather than two separate members, so the no-target case
still owns a real mutex directly without growing `SBMutex`'s size across
the ABI boundary.

Signed-off-by: Med Ismail Bennani <[email protected]>
https://invent.kde.org/qt/clang/llvm-project/-/commit/251ab4a3f2a2e0e8def833067064d5ad2b7efad9

Git commit 64c61f9173a651251e4d968d2cf9ccc323c4c818 by GitHub (on behalf of Piyush Jaiswal) on 14/08/2026 at 22:31..
[lldb] Read `read-only` pointee data from the object file in `GetPointeeData` (#213372)

## Summary 

`ValueObject::GetPointeeData` reads multi-element pointee data through
`eAddressTypeLoad` by calling
`Target::ReadMemory` with `force_live_memory=true`. That forces the read
to
come from live process memory and skips the object file's read-only
section cache.

For data that lives in a read-only section (e.g. a `const char *` or
**array**
in `.rodata`), the correct bytes may only be available from the object
file rather than the live process image. This is common with core files,
where read-only, file-backed pages are frequently not dumped: reading
such a pointee then returns stale or empty data (for example, a
`const char *` summary rendering as **""** instead of its real
contents).

Pass `force_live_memory=false` instead. `Target::ReadMemory` already
serves
read-only sections from the file cache and falls back to live process
memory, so this fixes the `read-only/core-file` case without regressing
live-process reads.

Add a ValueObject unit test that loads a read-only .rodata section,
attaches a process whose live reads return a sentinel byte, and verifies
GetPointeeData returns the section bytes rather than the live-memory
sentinel. The test fails if the flag is flipped back to true.

## Testing

Adds a unit test:
`GetPointeeDataTest.MultiElementReadPrefersReadOnlySection`

It loads a module with a read-only `.rodata` section holding four
`int32` values, loads that section at a known address, and attaches a
process whose live-memory reads always return a sentinel byte `(0xEE)`.
It then reads the four ints via `ValueObject::GetPointeeData`
(item_count > 1) and asserts the bytes come from the read-only section
(10, 20, 30, 40), not from the live-process sentinel.

### Build and run:

```
ninja LLDBValueObjectTests
./tools/lldb/unittests/ValueObject/LLDBValueObjectTests --gtest_filter='GetPointeeDataTest.*'
```

### Results:

```
[==========] Running 1 test from 1 test suite.
[----------] Global test environment set-up.
[----------] 1 test from GetPointeeDataTest
[ RUN      ] GetPointeeDataTest.MultiElementReadPrefersReadOnlySection
[       OK ] GetPointeeDataTest.MultiElementReadPrefersReadOnlySection (11 ms)
[----------] 1 test from GetPointeeDataTest (11 ms total)

[----------] Global test environment tear-down
[==========] 1 test from 1 test suite ran. (12 ms total)
[  PASSED  ] 1 test.
```

Results:
- With the fix (force_live_memory=false): PASSES.
- Reverting the fix (force_live_memory=true): FAILS the read returns
  the live-process sentinel (0xEEEEEEEE = 4008636142) instead of the
  section values, confirming the test guards this change.

Co-authored-by: Piyush Jaiswal <[email protected]>
https://invent.kde.org/qt/clang/llvm-project/-/commit/64c61f9173a651251e4d968d2cf9ccc323c4c818

Git commit 9d59cb80da37091286993fcf7daaf5a72daa8726 by GitHub (on behalf of Adam Smith) on 14/08/2026 at 22:34..
[CIR] Mark record members as data, pad, or empty in CIRGen (#215175)

A record type still can't say whether it carries anything for argument
passing. The x86_64 classifier has to know that before it can drop an
empty class from a signature.

A field's mark comes from `isEmptyFieldForABI`, ported from
`isEmptyField` in `ABIInfoImpl.cpp`. Taking the ABI predicate rather
than the layout one is what gets C right. Given `struct E {}`, a struct
holding one `E` is empty for the ABI in C but not in C++.

An assert on every record checks the marks against
`isEmptyRecordForABI`, so the existing `-fclangir` tests exercise them.

One case is now NYI. A `[[no_unique_address]]` field that
`isEmptyFieldForLayout` drops from the layout can still hold ABI data.
With the field gone there is no member left to mark, so CIRGen says so
rather than emit a record that understates what it holds.

This is the second of three PRs. Nothing reads the marks yet. The
`padded` bool stays, and `computeStructDataSize` still uses it. The next
PR will properly use the marks and remove `padded`.

Assisted-by: Cursor / claude-opus-5
https://invent.kde.org/qt/clang/llvm-project/-/commit/9d59cb80da37091286993fcf7daaf5a72daa8726

Git commit 9921c41ae1655fa7ff6bf36609c6a7edc151d435 by GitHub (on behalf of Pavel Labath) on 14/08/2026 at 22:35..
[libc] Fix link errors in some hermetic tests (#216406)

There is a dependency loop between the __libc__ and the
LibcHermeticTestSupport targets. If a compiler introduces a call to
`extern "C" memcpy` to some __libc__ function, then we need to link
LibcHermeticTestSupport to satisfy that. But the hermetic implementation
simply forwards to LIBC_NAMESPACE::memcpy, which is in the __libc__
target.

Linking the libc library twice is a simple though unsatisfying solution
to this problem. I'm working on a more principled fix, but that is going
to take a while longer, so I'm adding this in the mean time.
https://invent.kde.org/qt/clang/llvm-project/-/commit/9921c41ae1655fa7ff6bf36609c6a7edc151d435

Git commit 2c4ecfaa452d24ae5871700f7f53226333759d5d by GitHub (on behalf of Adam Smith) on 14/08/2026 at 22:41..
[ABI][CIR][NFC] Mark the last X86AVXABILevel in the enum (#216339)

CIR CallConvLowering keeps one classifier per AVX level, so it sizes an
array by the number of levels. It got that number as the current end of
the list plus one, which stops being the count the moment a level is
added after the current end. A runtime assert was necessary to guard the
index.

The enum now names its own last enumerator and CallConvLowering derives
the count from it.

Follow-up to review feedback deferred on #215118.

Assisted-by: Cursor / claude-opus-5
https://invent.kde.org/qt/clang/llvm-project/-/commit/2c4ecfaa452d24ae5871700f7f53226333759d5d

Git commit 5f8424668b51bb754cb899a0dd8ab3eceabb5913 by GitHub (on behalf of Augusto Noronha) on 14/08/2026 at 22:41..
[lldb] Run TestDenyAttach only with locally built debug server (#216399)

The PT_DENY_ATTACH handling is in debugserver, so a system debugserver
still reports lost connection. Added @skipIfOutOfTreeDebugserver
https://invent.kde.org/qt/clang/llvm-project/-/commit/5f8424668b51bb754cb899a0dd8ab3eceabb5913

Git commit 22c6fdf930c0655a3afcf6153dbaef02996e746e by GitHub (on behalf of Ehsan Amiri) on 14/08/2026 at 22:45..
[LoopFusion] Remove non-ascii character from comment [NFC] (#216413)
https://invent.kde.org/qt/clang/llvm-project/-/commit/22c6fdf930c0655a3afcf6153dbaef02996e746e

Git commit 09e5c526e49a22727346932d727d568712cbeb0b by GitHub (on behalf of Matt Arsenault) on 14/08/2026 at 22:50..
RuntimeLibcalls: Stop improperly reporting fp128 long double calls on ARM (#215917)

32-bit ARM's long double is IEEE double, so l suffixed calls do not have
fp128 type. Additionally, the f128 typed / suffixed functions are not built in
glibc as __HAVE_FLOAT128 is defined to 0 in the arch config. Remove the 
testcases which emitted nonexistent or wrongly typed calls and replace with 
error tests.

Related: #44744

Co-authored-by: Claude (Claude-Opus-4.8) <[email protected]>

---------

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

Git commit 27e012bb1d900dd3733d80ab5e9ab5d32e5f4f2e by GitHub (on behalf of dmaclach) on 14/08/2026 at 23:00..
[clang] Fix RecursiveASTVisitor to traverse the exception parameter in ObjCAtCatchStmt. (#216125)

Ensures that the catch parameter declaration (the exception variable) in
an Objective-C @catch block is visited during AST traversal. Previously,
this declaration was skipped. A unit test has been added to verify the
fix.
https://invent.kde.org/qt/clang/llvm-project/-/commit/27e012bb1d900dd3733d80ab5e9ab5d32e5f4f2e

Git commit f6b1016033b242fea920954d8a9be103d206ce34 by GitHub (on behalf of dmaclach) on 14/08/2026 at 23:08..
[clang][include-cleaner] Support ObjC @selector expressions in WalkAST (#212564)

This change adds support for resolving Objective-C @selector expressions
to their corresponding method or property declarations.

A lazy secondary pass is introduced to map selectors to their
declarations (methods, property getters, and property setters) across
the translation unit. When the AST walker encounters an
ObjCSelectorExpr, it reports the matching declarations as ambiguous
references.
https://invent.kde.org/qt/clang/llvm-project/-/commit/f6b1016033b242fea920954d8a9be103d206ce34

Git commit 120a8b78e80ba0896758a45e667980b433f62d74 by GitHub (on behalf of Nico Weber) on 14/08/2026 at 23:11..
[gn build] Port 251ab4a3f2a2 (#216427)
https://invent.kde.org/qt/clang/llvm-project/-/commit/120a8b78e80ba0896758a45e667980b433f62d74

Git commit b3601a33dfefe31138d66f37382356f0fb5d1b9b by GitHub (on behalf of Mehdi Amini) on 14/08/2026 at 23:14..
[MLIR][TableGen] Fix EnumAttr not recognized as enum in OpFormatGen (#189046)

`Attribute::isEnumAttr()` checked `isSubClassOf("EnumAttrInfo")`, but
the newer `EnumAttr` class (from `mlir/include/mlir/IR/EnumAttr.td`)
extends `AttrDef`, not `EnumAttrInfo`. This caused `canFormatEnumAttr`
in `OpFormatGen.cpp` to return `false` for `EnumAttr`-backed attributes,
forcing them to use the generic format path instead of the enum keyword
format path.

The fix has two parts:
1. Update `Attribute::isEnumAttr()` to also check
`isSubClassOf("EnumAttr")`.
2. Add `getEnumInfoRecord()` helper in `OpFormatGen.cpp` that, for
`EnumAttr`-based attributes, retrieves the `enum` sub-field (which is
the actual `EnumInfo` record) rather than the attribute def itself.
Update `canFormatEnumAttr`, `genEnumAttrParser`, and
`genEnumAttrPrinter` to use this helper.

Add a test to `op-format.td` verifying that an `EnumAttr`-wrapped enum
generates the enum keyword format (symbolize/stringify calls).

Fixes #180455

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

Git commit fbc0797d18bdd51178ee8f654a0dbbace6ff2db1 by GitHub (on behalf of Marc Auberer) on 14/08/2026 at 23:15..
[Support] Remove deprecated endian::byte_swap/read/write overloads (#216300)

These overloads took the endianness as a template parameter and were
deprecated in favour of the versions that take it as a function
argument. There are no remaining in-tree users, so drop them.

Co-authored-by: Claude <[email protected]>
https://invent.kde.org/qt/clang/llvm-project/-/commit/fbc0797d18bdd51178ee8f654a0dbbace6ff2db1

Git commit db315b5bc43963f6c65d8754809ae9641662d883 by GitHub (on behalf of Jonas Devlieghere) on 14/08/2026 at 23:16..
Undo botched rebase (#216421)

When rebasing #215393, I accidentally pulled in the change for #215952.
I then later rebased the latter, leaving only the changes requested
during review. Undo this mess so I can land the two PRs correctly.
https://invent.kde.org/qt/clang/llvm-project/-/commit/db315b5bc43963f6c65d8754809ae9641662d883

Git commit 5aec94a1869b870428eac645ba9c7c34c76495da by GitHub (on behalf of Jonas Devlieghere) on 14/08/2026 at 23:49..
[lldb] Search for a corefile's images before loading any of them (#216431)

A userland or kernel corefile can list hundreds of images, and searching
for one can shell out to a symbol server or fetch over the network.
Searching for them one at a time is where loading such a corefile spends
its time.

Add a batch form of SymbolLocator::Locate that runs the searches on the
debugger's thread pool, gated on target.parallel-module-load. Results
come back in the order the requests were given, since that order decides
the Target's module order. Only the results are ordered, and anything a
search reports to the user arrives in whatever order the searches finish
in.

Only the plugin searches run concurrently, so a platform hook does not
have to be thread safe to take part, and reading a binary's UUID out of
memory stays on the calling thread.

Setting up a platform binary can replace the Target's platform and
dynamic loader, and now happens for every image before any of them is
searched for, so the platform a corefile asks for is the one all of its
images are searched with. Previously the images listed ahead of a
platform binary were searched with whatever platform preceded it.

Assisted-by: Claude
https://invent.kde.org/qt/clang/llvm-project/-/commit/5aec94a1869b870428eac645ba9c7c34c76495da

Git commit 5f491a454cb855179295c0463622393df0c5bb42 by GitHub (on behalf of Andy Kaylor) on 14/08/2026 at 23:56..
[LLVMABI] Create a skeleton for AArch64 ABI handling (#216222)

This change adds the most basic implementation of llvm::abi::TargetInfo
for AArch64 targets and establishes a unit test for it.

There was no isolated testing for previous targets implemented in the
ABI library. They were only tested through clang. My plan with AArch64
is to create unit tests so that the library can be tested without
building the clang target, but also to have clang tests so that the
handling can be compared to clang's ABI handling as a meaningful point
of reference for correct behavior.

For this initial change, because no real handling is implemented yet, I
am not introducing the clang hook or any clang-based tests.

Assisted-by: Cursor / Grok 4.5 (test generation)
https://invent.kde.org/qt/clang/llvm-project/-/commit/5f491a454cb855179295c0463622393df0c5bb42

Git commit 8a6a59a0b4b06e43e508b7ff4c19cbfa3719f777 by GitHub (on behalf of Jonas Devlieghere) on 15/08/2026 at 00:07..
[DWARFLinker] Constrain a function's high_pc to its own symbol (#216432)

Mach-O objects built with .subsections_via_symbols make every symbol an
independently placeable atom, and the linker packs atoms without
preserving the spacing they had in the object file.

I have an example where the compiler describes such a subprogram as
extending past its own atom. While it's debatable whether that's a good
idea, it's not invalid in the object file. However, once linked, it is
invalid.

We can make dsymutil resilient against this by looking at the size of
the symbol in the debug map and adjusting the end_pc. I'm doing so
conservatively so that only a collision is repaired. Already
overlapping/invalid ranges remain untouched.

rdar://184768778
https://invent.kde.org/qt/clang/llvm-project/-/commit/8a6a59a0b4b06e43e508b7ff4c19cbfa3719f777

Git commit 47aa7b93b9ccc8980066abcbdcab6134b1a90105 by GitHub (on behalf of Dmitry Sidorov) on 15/08/2026 at 00:09..
[NFC][SLP] Add a test for fma fusion with the fmul on operand 1 (#216428)

canConvertToFMA only looks at operand 0 of the fadd, so the accumulator
shape fadd c, a * b is never recognised, and the fmul it does find is
priced with the target's fusion discount already applied. The threshold
puts the decision right at the cost boundary so the checks record which
way SLP goes today.
https://invent.kde.org/qt/clang/llvm-project/-/commit/47aa7b93b9ccc8980066abcbdcab6134b1a90105

Git commit 7dc88cc057376aafeb1d6ecd95135286f2bb8c25 by GitHub (on behalf of Craig Topper) on 15/08/2026 at 00:22..
[RISCV] Remove short-forward-branch-imm. (#216401)

Just use short-forward-branch-ialu. I hope implentations that implement
short-forward-branch, do it equally for all branch types. Doing anything
else would create complex tradeoffs.

I'm planning to add conditional c.mv fusion support for Zibi and I don't
want to add an immediate version flag there.

The patterns that checked NoShortForwardBranchImm were not checking that
an immediate branch ISA was enabled. So I've changed them to
NoVendorXqcibiOrNoShortForwardBranch.
https://invent.kde.org/qt/clang/llvm-project/-/commit/7dc88cc057376aafeb1d6ecd95135286f2bb8c25

Git commit 8024076c7591b6477d23c3519652a7c6487d97d3 by GitHub (on behalf of Alexey Bataev) on 15/08/2026 at 01:07..
[SLP]Recalculate copyable-element deps after tree reordering

Reordering permutes the operand columns of the entries and may move an
operand between copyable-covered and plain edges, making the computed
dependency counts stale and tripping the unscheduled-deps assertion.

Reviewers: 

Pull Request: https://github.com/llvm/llvm-project/pull/216442
https://invent.kde.org/qt/clang/llvm-project/-/commit/8024076c7591b6477d23c3519652a7c6487d97d3

Git commit 34cce43ff1918e621ab08411fa7bc0e2ac4165b4 by GitHub (on behalf of Alexey Bataev) on 15/08/2026 at 02:08..
Revert "[SLP]Recalculate copyable-element deps after tree reordering"

This reverts commit 8024076c7591b6477d23c3519652a7c6487d97d3 to fix
buildbot https://lab.llvm.org/buildbot/#/builders/210/builds/12275

Reviewers: 

Pull Request: https://github.com/llvm/llvm-project/pull/216444
https://invent.kde.org/qt/clang/llvm-project/-/commit/34cce43ff1918e621ab08411fa7bc0e2ac4165b4

Git commit 125c8d39b441dd99f1b1d55b536ad0d821b8fb71 by GitHub (on behalf of Jonas Devlieghere) on 15/08/2026 at 02:31..
[DWARFLinker] Index Swift mangled type names in the parallel linker (#216429)

Swift records a type's mangled name in DW_AT_linkage_name. The classic
linker indexes it as a type accelerator entry alongside the short
DW_AT_name, but the parallel linker indexed only the short name.

Port the DW_LANG_Swift block added to the classic linker in 8234f8ae2685
to the parallel linker's type case.
https://invent.kde.org/qt/clang/llvm-project/-/commit/125c8d39b441dd99f1b1d55b536ad0d821b8fb71

Git commit b43c56b2b8745ca73539dbc4c48da1686530102c by GitHub (on behalf of Peiqi Li) on 15/08/2026 at 03:28..
[clangd][clang-tidy] Factor out mergeFixits() logic and reuse it in clangd (#208682)

This patch extracts `mergeFixits()` from `DiagnosticRenderer` to
`clang::edit` and reuses it in clangd. This prevents syntax errors
caused by token merging when applying clang-tidy fixits via clangd.

Fixes #207618
https://invent.kde.org/qt/clang/llvm-project/-/commit/b43c56b2b8745ca73539dbc4c48da1686530102c

Git commit 05ed2687e98b590641bf9f6505321c319de6bba0 by GitHub (on behalf of Helena Kotas) on 15/08/2026 at 04:34..
[NFC][DirectX] Rename ResourceInfo::RecordID to BindingID (#216376)

Rename `ResourceInfo::RecordID` to `BindingID` to better reflect its
purpose. This field is set only for resources with an associated
binding. This also clarifies the distinction from the upcoming
`HeapResourceID` member, which will identify resources originating from
a heap. The existing `RecordID` name could be ambiguous once both
identifiers are present.

The change also removes the `RecordID` argument from the `ResourceIfo`
constructor because it has always been called with `0` value. The
`BindingID` is set later via `setBindingID` after all resource instances
are collected.
https://invent.kde.org/qt/clang/llvm-project/-/commit/05ed2687e98b590641bf9f6505321c319de6bba0

Git commit 22eba47a1c4533e9383a422edd29d46d903a43a4 by GitHub (on behalf of Sriraman Tallam) on 15/08/2026 at 04:36..
[ELF] Prevent .eh_frame_hdr size oscillation in address assignment (#216248)

When .eh_frame_hdr size shifts, section addresses can change whether
FDEs evaluate to identical PC-relative offsets, causing FDE
deduplication count to toggle and section size to oscillate infinitely
between passes.

Prevent .eh_frame_hdr from shrinking during iterative address assignment
passes (matching .relr.dyn) to ensure monotonic convergence.
https://invent.kde.org/qt/clang/llvm-project/-/commit/22eba47a1c4533e9383a422edd29d46d903a43a4

Git commit 23e0cbe9a37fdd7addfd461ace6b480ad423e36b by GitHub (on behalf of MrEven132) on 15/08/2026 at 05:46..
[LLDB] fix lldb breg adress width (#216291)

`DW_OP_breg0..31` and `DW_OP_bregx` preserved the scalar width supplied
by the register backend and added their displacement as a `uint64_t`. On
32-bit targets this could leave a 64-bit value on the expression stack,
so later generic address arithmetic did not wrap at the target address
size.

Perform the register-plus-offset calculation using the evaluator's
address-sized generic representation. This keeps `DW_OP_breg*` results
at the target address width without changing shared register reading or
the generic
operand compatibility rule.

Add unit tests for both compact and extended breg opcodes. They cover a
32-bit register value, a backend-provided 64-bit register value on i386,
a negative displacement, and modulo-32-bit overflow.

Fixes #209728
https://invent.kde.org/qt/clang/llvm-project/-/commit/23e0cbe9a37fdd7addfd461ace6b480ad423e36b

Git commit 585178db7f1488753cbdf1875c94e3eb74b7dadc by GitHub (on behalf of Benjamin Maxwell) on 15/08/2026 at 06:28..
[AArch64] Remove search size limit in VECTOR_MATCH lowering (#215786)

Any legal (64/128-bits) needle vector can be lowered to `match`.
https://invent.kde.org/qt/clang/llvm-project/-/commit/585178db7f1488753cbdf1875c94e3eb74b7dadc

Git commit bbff70cb65872bcefe6ee818015b14a82b1ccf12 by GitHub (on behalf of Kirill Vedernikov) on 15/08/2026 at 06:56..
[NVPTX] Add tcgen05.mma kind::ti16 for sm_107f + mxf4{nvf4} for sm_107a (#215624)

Extend NVPTX `tcgen05.mma*` with `kind::ti16` for `sm_107f`.
https://invent.kde.org/qt/clang/llvm-project/-/commit/bbff70cb65872bcefe6ee818015b14a82b1ccf12

Git commit 3eeed35b3ea3de8d3fbd2bf1b1b49b983181ac0f by GitHub (on behalf of Marc Auberer) on 15/08/2026 at 07:21..
[ADT] Mark deprecated APInt constructor deleted (#216371)

Mark deprecated APInt constructor, taking uint64_t[] deleted instead of
removing it as the comment suggests.
https://invent.kde.org/qt/clang/llvm-project/-/commit/3eeed35b3ea3de8d3fbd2bf1b1b49b983181ac0f

Git commit 500afbdbc4b28414912fdb7eef5edc9fbc90a7cb by GitHub (on behalf of mkovacevic99) on 15/08/2026 at 08:34..
[JITLink][ORC] Add ppc64 to generic stub API; use it in DLLImportDefinitionGenerator (#207968)

`getAnonymousPointerCreator` and `getPointerJumpStubCreator` provide
arch-neutral factory functions for pointer slots and PLT jump stubs, but
ppc64/ppc64le were missing from both switch tables.

Add ppc64 support: `createAnonymousPointer` maps directly, while
`createAnonymousPointerJumpStub` requires a lambda wrapper to fix the
endianness template parameter and supply _LongBranchSaveR2_ as the stub
kind (the correct default for external calls that must preserve the TOC
pointer). Callers needing a different stub kind can construct a
`PointerJumpStubCreator` lambda directly. Update
`DLLImportDefinitionGenerator::createStubsGraph` to use these
arch-neutral factories instead of calling jitlink::x86_64:: directly,
completing part of the work tracked in issue
https://github.com/llvm/llvm-project/issues/57162
https://invent.kde.org/qt/clang/llvm-project/-/commit/500afbdbc4b28414912fdb7eef5edc9fbc90a7cb

Git commit c15928e9a21520819fe5b5f154b564ecc958aeb3 by GitHub (on behalf of David Green) on 15/08/2026 at 09:27..
[GlobalISel] Add G_SEXT_INREG(G_ZEXT) -> G_SEXT combine. (#213606)

This converts a G_ZEXT or G_ANYEXT to a G_SEXT if we will G_SEXT_INREG
the bits away.
https://invent.kde.org/qt/clang/llvm-project/-/commit/c15928e9a21520819fe5b5f154b564ecc958aeb3

Git commit 1ebbabeabe797ea97481d353b87a7d6f9607818b by GitHub (on behalf of Amr Hesham) on 15/08/2026 at 09:52..
[CIR][NFC] Remove unnecessary casts in LowerToLLVM (#216395)

Remove unnecessary casts for Op with TypeConstraints and known type for
operands in the LowerToLLVM
https://invent.kde.org/qt/clang/llvm-project/-/commit/1ebbabeabe797ea97481d353b87a7d6f9607818b

Git commit af15d15f9bbd5ac5d3f020d270b38ffe01b0a72a by GitHub (on behalf of Björn Schäpers) on 15/08/2026 at 09:56..
[clang-format] Harden star and amp annotation (#212856)

At this point we can't (or won't) decide wether this is a template
argument or just an expression, opt out of the specialized (and in the
test cases wrong) assignment.

Fixes #212622
https://invent.kde.org/qt/clang/llvm-project/-/commit/af15d15f9bbd5ac5d3f020d270b38ffe01b0a72a

Git commit 7afbf0f3e79f00fda49202214dd2917805b8529d by GitHub (on behalf of NAKAMURA Takumi) on 15/08/2026 at 10:04..
SignAnalysisTest.cpp: Suppress a warning. [-Wunused-template] (#215563)
https://invent.kde.org/qt/clang/llvm-project/-/commit/7afbf0f3e79f00fda49202214dd2917805b8529d

Git commit e45f256d0389ca5f9536dcd949680c1097ef9728 by GitHub (on behalf of NAKAMURA Takumi) on 15/08/2026 at 10:11..
IntervalPartitionTest.cpp: Suppress a warning. [-Wunused-template] (#215564)

I think it'd be fair just to suppress since this is just a test.
https://invent.kde.org/qt/clang/llvm-project/-/commit/e45f256d0389ca5f9536dcd949680c1097ef9728

Git commit 3ee35aec0bc1d98dd724b95b7eb5d69109c40ca1 by GitHub (on behalf of Andreas Jonson) on 15/08/2026 at 10:18..
[InstCombine] support zext in ceiling division fold (#216470)

Proof https://alive2.llvm.org/ce/z/vxRGV7
https://invent.kde.org/qt/clang/llvm-project/-/commit/3ee35aec0bc1d98dd724b95b7eb5d69109c40ca1

Git commit 367b306e9c12e16621b27e606bfbb765166a6b96 by GitHub (on behalf of Florian Hahn) on 15/08/2026 at 10:21..
[ConstraintElimination] Fix trivially true compares with no variables. (#216392)

getConstraintForSolving handles 'X uge 0' and '0 ule X' directly,
returning a constraint that is trivially true. The returned row was sized
Value2Index.size(), which is 0 if the unsigned system does not have any
variables yet, e.g. in a function without arguments. An empty row means
the condition could not be decomposed, so the fast path was discarded and
the compare not simplified.

Size the row to include the entry for the constant part, so it is never
empty.

PR: https://github.com/llvm/llvm-project/pull/216392
https://invent.kde.org/qt/clang/llvm-project/-/commit/367b306e9c12e16621b27e606bfbb765166a6b96

Git commit 3fac4696def1e29cede7ee05db3cbdf0fcc98cef by GitHub (on behalf of Arseniy Obolenskiy) on 15/08/2026 at 10:37..
[AMDGPU] Fix BFE_U32 fold to check known zero bits instead of sign bits (#216310)
https://invent.kde.org/qt/clang/llvm-project/-/commit/3fac4696def1e29cede7ee05db3cbdf0fcc98cef

Git commit 4883f1131203981da6fa4573fe55d0ae6cf1c301 by GitHub (on behalf of lonely eagle) on 15/08/2026 at 10:59..
[mlir][affine] Add early exit to getLowerBound/getUpperBound function (NFC) (#212047)

When an AffineExpr is an AffineConstantExpr, its bound can be directly
returned without computing the lower/upper bounds for all operand
values. This avoids redundant bound evaluations on operands and speeds
up static bound computation.
https://invent.kde.org/qt/clang/llvm-project/-/commit/4883f1131203981da6fa4573fe55d0ae6cf1c301

Git commit f406aaec5f6dcb8dbe5d7267afdfdf80cea29d32 by GitHub (on behalf of Lang Hames) on 15/08/2026 at 12:21..
[ORC] Remove Orc/RTBridge, split utilities from SPS bindings (#216473)

RTBridge was a holding pen for the new proxy APIs, and its name collided
confusingly with Shared/OrcRTBridge.h. Move its contents into Orc/ and
delete it:

  RTBridge/Proxy.h              -> Proxy.h
  RTBridge/SPS/ProxySpec.h      -> SPSProxySpec.h
  RTBridge/CallProxies.h        -> CallProxies.h
  RTBridge/SPS/CallProxySpecs.h -> CallProxiesSPS.h

Drop rt:: from the proxy machinery: Proxy is not runtime specific, but a
general-purpose utility for calling code in the executor (it abstracts
over dispatch mechanism and serialization).

SPS dispatch becomes llvm::orc::sps::ProxySpec. Controller-interface
descriptors keep llvm::orc::rt::sps_ci -- those really are
runtime-specific.

Each EPCGeneric* utility now splits in two: a protocol-agnostic header
with the class, its proxy typedefs and its Funcs/Bindings struct, plus a
companion holding the ProxySpecs and a factory:

  EPCGenericMemoryAccessSPS.h
  EPCGenericDylibManagerSPS.h
  EPCGenericJITLinkMemoryManagerSPS.h

The class headers previously claimed to be protocol-agnostic while
including the SPS specs and instantiating them inline in Create; they
now pull in neither SPSProxySpec.h nor any SPSCI descriptor. The specs
stay public so clients can still resolve operations under non-default
names via proxyInit<Spec>(&P, Name).

The static Create methods become sps::createEPCGeneric* free functions
returning Expected<std::unique_ptr<Concrete>>. EPCGenericDylibManager
previously returned by value, so its callers no longer wrap the result
in make_unique. The SymbolLookupSet SPS serialization specialization
moves to EPCGenericDylibManagerSPS.cpp, its only user.
https://invent.kde.org/qt/clang/llvm-project/-/commit/f406aaec5f6dcb8dbe5d7267afdfdf80cea29d32

Git commit c7f4a76da024fe59fa26b1213632f85c036fa64c by GitHub (on behalf of Pranav Alavandi) on 15/08/2026 at 12:55..
[InstCombine] fold ((x - 1) | (2^k - 1)) + 1 to (x + (2^k - 1)) & -(2^k) (#216436)

Fold `((x - 1) | (C - 1)) + 1 to (x + (C - 1)) & -(C)` for a power of 2 `C`

Fixes issue: https://github.com/llvm/llvm-project/issues/215945
Generalized proof: https://alive2.llvm.org/ce/z/tQubkT

Similar to https://github.com/llvm/llvm-project/pull/215122 and
corresponding issue https://github.com/llvm/llvm-project/issues/214675
https://invent.kde.org/qt/clang/llvm-project/-/commit/c7f4a76da024fe59fa26b1213632f85c036fa64c

Git commit 7a7e0f78d003e6e6ba885d5c16deed22004ebd1d by GitHub (on behalf of Alexey Bataev) on 15/08/2026 at 13:29..
[SLP]Recalculate copyable-element deps after tree reordering

Reordering permutes the operand columns of the entries and may move an
operand between copyable-covered and plain edges, making the computed
dependency counts stale and tripping the unscheduled-deps assertion.

Reviewers: 

Pull Request: https://github.com/llvm/llvm-project/pull/216490
https://invent.kde.org/qt/clang/llvm-project/-/commit/7a7e0f78d003e6e6ba885d5c16deed22004ebd1d

Git commit 246ee06e2e8805255cd3f907d5e2f86422c6cac6 by GitHub (on behalf of Folkert de Vries) on 15/08/2026 at 13:36..
[RISCV] make `_Complex {integer}` consistent with GCC (#216404)

The Loongarch fix from https://github.com/llvm/llvm-project/pull/215222
but for riscv, which hits the same issue.

Clang appears to pass `_Complex short` and `_Complex char` like a struct
with two `short`/`char` fields, taking up 2 registers. GCC instead packs
the values together into a single register.

https://godbolt.org/z/dKhPToqcd

```c
struct S { _Complex unsigned short c; };

void callee(struct S s);

void caller(void) {
    struct S s;
    __real__ s.c = 0xC1C0;
    __imag__ s.c = 0xD1D0;
    callee(s);
}
```

Clang uses both `a0` and `a1`:

```asm
caller:
        lui     a0, 12
        lui     a1, 13
        addi    a0, a0, 448
        addi    a1, a1, 464
        tail    callee
```

GCC bitpacks everything into `a0`:

```asm
caller:
        addi    sp,sp,-16
        sd      ra,8(sp)
        li      a0,-774848512
        addiw   a0,a0,448
        call    callee@plt
        ld      ra,8(sp)
        addi    sp,sp,16
        jr      ra
```

Complex integers are a GNU extension, so clang behavior should match
GCC.
https://invent.kde.org/qt/clang/llvm-project/-/commit/246ee06e2e8805255cd3f907d5e2f86422c6cac6

Git commit 227ec3e87fd013ad1963827144ff8f6e9d762510 by GitHub (on behalf of Chris Apple) on 15/08/2026 at 14:21..
[sanitizer-common][rtsan] Fix log and stack printing for rtsan (#215707)

Fixes:
* sanitizer_common/TestCases/suffix-log-path_test.c
* sanitizer_common/TestCases/print-stack-trace.cpp


These two tests have some overlap, which is why they are fixed in the
same commit. Functionally, this means:
* RTSan now exports the common `__sanitizer_print_stack_trace` API, from
what I understand from the comment on the master version of this, this
is for debuggers to call
* RTSan can now report out to a log file using the common utilities
https://invent.kde.org/qt/clang/llvm-project/-/commit/227ec3e87fd013ad1963827144ff8f6e9d762510

Git commit 1cb114a48974f45767c2c4af4bb4647cff8eaf7d by GitHub (on behalf of Alexey Bataev) on 15/08/2026 at 14:29..
[SLP]Fix root PHI reordering when the root order must be preserved

Do not move the operand order onto the tree-root PHI in
reorderBottomToTop() when IgnoreReorder is false (e.g. ordered
reductions): the root has no user to take over the order and it cannot
be dropped.

Fixes #216453

Reviewers: 

Pull Request: https://github.com/llvm/llvm-project/pull/216493
https://invent.kde.org/qt/clang/llvm-project/-/commit/1cb114a48974f45767c2c4af4bb4647cff8eaf7d

Git commit 3196161be84becc68c891517a707daf6739a2dd3 by GitHub (on behalf of Daniel Chen) on 15/08/2026 at 15:20..
[flang] To issue error message for unsupported usage of vector type. (#215248)

As discussed in PR #214219, we don't plan to support any usage that
requires runtime descriptor for vector type object.
Flang has already disallowed ALLOCATABLE, POINTER, ASSUMED-SHAPE and
ASSUMED-RANK for vector types.
The test reducer posted by @eugeneepshteyn should also be flagged by the
compiler as an error.
This PR is to add semantic check for that case. It covers
1. Vector type declaration statement that has ALLOCATABLE or POINTER
attribute.
2. ALLOCATE statement where SOURCE= or MOLD= has a vector type object.
3. Auto-allocation intrinsic assignment where the RHS is a vector type
object.
4. A vector type object being used as an argument of SAME_TYPE_AS or
EXTENDs_TYPE_OF.
5. A vector type object being used as the `dtv` argument of a UDIO.
6. A vector type object being used as the argument of `CLASSOF`.
https://invent.kde.org/qt/clang/llvm-project/-/commit/3196161be84becc68c891517a707daf6739a2dd3

Git commit f1c43628899ee8087804f1fba8497488370278a1 by GitHub (on behalf of Craig Topper) on 15/08/2026 at 15:32..
[RISCV] Simplify the Zibi SFB and select patterns. NFC (#216449)

Use a PatLeaf to match the valid condition codes instead of using
separate patterns for each.
https://invent.kde.org/qt/clang/llvm-project/-/commit/f1c43628899ee8087804f1fba8497488370278a1

Git commit e2f924dda79034eda183638cf6f0032997eafef0 by GitHub (on behalf of Kazu Hirata) on 15/08/2026 at 16:18..
[Analysis] Remove dead declarations (#216466)

getDVEntry: Added on October 10, 2025 in commit
1e84cb512748742e244d1062ef64f76764127423 without a corresponding
function definition.

releaseMemory: Added on March 10, 2016 in commit
61440d225b0869aa1c82a0d76e6311eccf7307bc without a corresponding
function definition.

analyzeKnownFPClassFromSelect: Added on January 8, 2026 in commit
80296b618e648ef56ea5e5bbf1b34be6b1b72dcf without a corresponding
function definition.
https://invent.kde.org/qt/clang/llvm-project/-/commit/e2f924dda79034eda183638cf6f0032997eafef0

Git commit ec1be67e3e0300c628bece313c74f1417270af6a by GitHub (on behalf of KIM SO JUNG) on 15/08/2026 at 16:21..
[Object][Wasm] Guard relocation diagnostics against out-of-range indexes (#204872)

The badReloc lambda in parseRelocSection() accesses Symbols[Reloc.Index]
when building diagnostic messages, even after validation has determined
that Reloc.Index is out of range. This causes a heap out-of-bounds read
that can crash LLVM tools or produce unexpected diagnostic output.

Fix by checking Reloc.Index against Symbols.size() before dereferencing,
and emit the numeric index in the error message when out of range.

The vulnerable diagnostic path is shared across multiple relocation type
validation failures, including R_WASM_FUNCTION_INDEX_LEB,
R_WASM_TAG_INDEX_LEB, R_WASM_TABLE_NUMBER_LEB, and
R_WASM_MEMORY_ADDR_LEB.

Note: this is a minimal fix addressing the out-of-bounds access. The
R_WASM_TYPE_INDEX_LEB path validates against Signatures.size() but
badReloc() still references Symbols[Reloc.Index], which may warrant
a broader diagnostic refactoring separately.
https://invent.kde.org/qt/clang/llvm-project/-/commit/ec1be67e3e0300c628bece313c74f1417270af6a

Git commit 4ba253c52cfe1d18f27ad4a4641f0ad75cf2e6e9 by GitHub (on behalf of Kamlesh Kumar) on 15/08/2026 at 16:53..
[IR][Intrinsics] Fix llvm.powi to require a scalar integer exponent (#216160)

Fix llvm.powi intrinsic to enforce a scalar integer exponent,
aligning the implementation with the LangRef specification.
https://invent.kde.org/qt/clang/llvm-project/-/commit/4ba253c52cfe1d18f27ad4a4641f0ad75cf2e6e9

Git commit 0c2e521f8b587b0c3fb5825fb157c3938fef4ff6 by GitHub (on behalf of Yao Qi) on 15/08/2026 at 16:56..
[lldb][test] Skip the frame 0 stack expedite test with an out-of-tree debugserver (#216496)

test_threads_info_expedites_stopped_frame_stack asserts that
jThreadsInfo
carries frame 0's stack memory for the stopped thread. debugserver only
does
that since b631e0cbd1c9, so a system debugserver sends the backchain
alone and
the test fails with "no frame 0 stack memory for stopped thread".
https://invent.kde.org/qt/clang/llvm-project/-/commit/0c2e521f8b587b0c3fb5825fb157c3938fef4ff6

Git commit e5174fe683e882f6bbd2ef023c9c9e293b273a98 by GitHub (on behalf of Zorojuro) on 15/08/2026 at 18:17..
[libc] Make ceilf128 use the emulated float128 type (#207735)

This tests the emulated float128 type using ceilf128
https://invent.kde.org/qt/clang/llvm-project/-/commit/e5174fe683e882f6bbd2ef023c9c9e293b273a98

Git commit 83e1178daa1243fc7892f88b79aaea2dc555b8ce by GitHub (on behalf of DeanSturtevant1) on 15/08/2026 at 19:40..
[bazel] Fix bazelisk failures after ORC RTBridge removal and libc float128 (#216505)

…at128

Commit f406aaec5f6dcb8dbe5d7267afdfdf80cea29d32 removed the ORC/RTBridge
directory and relocated its headers directly under
include/llvm/ExecutionEngine/Orc/. This updates OrcJIT and OrcShared in
llvm/BUILD.bazel to remove the obsolete RTBridge header glob patterns.

Additionally, this adds the missing :__support_fputil_float128 target in
libc/BUILD.bazel and includes it in the dependencies of
:__support_math_ceilf128 and :shared_math_headers_for_apfloat.

TAG=agy
CONV=cdc6d2a4-4a43-464a-ae1b-a56f935ee140
https://invent.kde.org/qt/clang/llvm-project/-/commit/83e1178daa1243fc7892f88b79aaea2dc555b8ce

Git commit 993ade261e1ac216cf44aec44fadc81e1bc3bce3 by GitHub (on behalf of Kazu Hirata) on 15/08/2026 at 20:19..
[ADT] Add const and reverse iterators to SortedVectorMap (#216439)

This patch adds cbegin, cend, rbegin, rend, crbegin, and crend to
SortedVectorMap along with reverse_iterator and const_reverse_iterator
type aliases.

The motivation here is to support const and reverse iteration in
SortedVectorMap, which is needed by tools like llvm-profdata for the
ongoing sample profile migration to SortedVectorMap.

Assisted-by: Antigravity
https://invent.kde.org/qt/clang/llvm-project/-/commit/993ade261e1ac216cf44aec44fadc81e1bc3bce3

Git commit 22396993a985b1a86a1ddb241b5cdd0843c5d306 by GitHub (on behalf of Matt Arsenault) on 15/08/2026 at 20:19..
RuntimeLibcalls: Fix AArch64 wrongly typed long-double libcalls (#215993)

Respect the triple's LongDoubleFormat.

AArch64SystemLibrary added the fp128-typed frexpl/ldexpl and exp10l
without a long-double-format guard, so triples where long double is IEEE double
(Darwin, Windows, Android) were emitting l suffixed calls with the wrong
type.

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

Git commit 84219fa5bdebb9c72482999452a66f1bec536362 by GitHub (on behalf of Matt Arsenault) on 15/08/2026 at 21:57..
GlobalISel: Use MIPatternMatch to look up defs in CombinerHelper (#216507)

Replace direct getVRegDef uses that were followed by an opcode check
with the mi_match idiom, mirroring the artifact combiner cleanup in
2e172cd38272124da30cc913f1a372ba9ea59dcf. This handles a subset of
simple cases, others call for some nicer mi_match support.

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

Git commit 8f88dfdbe8ea21a312b805d4550ed1fa99a6205b by GitHub (on behalf of Benedek Kaibas) on 15/08/2026 at 22:11..
[analyzer] Correctly highlight the variables' range in UseAfterLifetimeEnd reports (#215905)

Currently in the emitted reports from the `UseAfterLifetimeEnd` checker
the highlight range of the variables is incorrect which can lead to
confusion for the user.

```
temp.cpp:5:31: note: Value's lifetime bound to the lifetime of 'y' here
    4 |   int x = 1, y = 2;
      |   ~~~~~~~~~~~~~~~~
```

In this emitted note the highlight of the variable `y` incorrectly spans
to the variable `x` as well and vice versa. This does not meet the
quality requirements of a core Clang Static Analyzer Checker.

In this PR I get the `VarDecl` of the `VarRegion` and then return the
`SourceRange` based on the `VarDecl`'s location through `getLocation`.
This leads to the following emitted notes:

```text
temp.cpp:5:37: note: Value's lifetime bound to the lifetime of 'y' here
    4 |   int x = 1, y = 2;
      |              ~
```
https://invent.kde.org/qt/clang/llvm-project/-/commit/8f88dfdbe8ea21a312b805d4550ed1fa99a6205b

Git commit 6d9a7754b01877001dbb8baa06cb98c1a405c46f by GitHub (on behalf of DeanSturtevant1) on 15/08/2026 at 22:16..
[libc][bazel] Update bazel overlay for ceilf128 emulated float128 changes (#216515)

This updates the Bazel overlay following commit
e5174fe683e882f6bbd2ef023c9c9e293b273a98:

- Remove `:llvm_libc_types_float128` from `__support_math_ceilf128` deps
as `include/llvm-libc-types/float128.h` is no longer included.
- Add `:__support_cpp_bit` to `ceilf128` additional_deps for `bit_cast`.
- Add `ceilf128` math MPFR test target in
`libc/test/src/math/BUILD.bazel`.
https://invent.kde.org/qt/clang/llvm-project/-/commit/6d9a7754b01877001dbb8baa06cb98c1a405c46f

Git commit 85cffe68c6fbab89d719a8076a07b9873ab9d514 by GitHub (on behalf of Matt Arsenault) on 15/08/2026 at 22:47..
AMDGPU: Use m_GTrunc in selector def check (#216511)

Prefer mi_match over raw getVRegDef + opcode checks.
https://invent.kde.org/qt/clang/llvm-project/-/commit/85cffe68c6fbab89d719a8076a07b9873ab9d514

Git commit e1ece3dfc7cb6e7882f5638aa79495869d4d5930 by GitHub (on behalf of Folkert de Vries) on 15/08/2026 at 22:57..
[MIPS][NFC] test mips variadic aggregate handling (#216509)

mips64 has some bugs here that I'll address in a followup. The problem
is that we get `inreg {float}` items in the variable argument list. That
breaks for aggregates like `_Complex long double` or just `struct { long
double a; b }`.
https://invent.kde.org/qt/clang/llvm-project/-/commit/e1ece3dfc7cb6e7882f5638aa79495869d4d5930

Git commit b8afe9fdd012f12df6155dfbf3222b13310e43ac by GitHub (on behalf of Alexey Bataev) on 15/08/2026 at 23:11..
[SLP][NFC]Add a test with non-profitable vectorization for GEPs external users, NFC



Reviewers: 

Pull Request: https://github.com/llvm/llvm-project/pull/216518
https://invent.kde.org/qt/clang/llvm-project/-/commit/b8afe9fdd012f12df6155dfbf3222b13310e43ac

Git commit 2393da9d2eeb9c41296138129074f11f1c64222a by GitHub (on behalf of David Green) on 15/08/2026 at 23:43..
[AArch64][GlobalISel] Do not create atomic truncstore (#216522)

After #213935 the i64->i32 truncstore was failing to create a COPY
correctly.
We do not have tablegen patterns, so mirror what SDAG does and do not
create
atomic truncstore.
https://invent.kde.org/qt/clang/llvm-project/-/commit/2393da9d2eeb9c41296138129074f11f1c64222a

Git commit ca017792fb043d24b683997a2d80eb79f933d14d by GitHub (on behalf of Chinmay Deshpande) on 15/08/2026 at 23:52..
[APFloat][NFC] Add unit test coverage for `getArbitraryFPSemantics` (#216501)

`isValidArbitraryFPFormat` and `getArbitraryFPFormatSizeInBits` have
unit tests, but `getArbitraryFPSemantics`, the mapping the conversion
intrinsics actually lower through, had none. Cover the formats it
supports, the valid formats it does not support yet, and invalid format
strings, and check that the two tables agree on the size of every format
with lowerable semantics.

Also add the missing Float8E5M3FNU case to the
`getArbitraryFPFormatSizeInBits` test.
https://invent.kde.org/qt/clang/llvm-project/-/commit/ca017792fb043d24b683997a2d80eb79f933d14d

Git commit cbb56261423435e4e3d6dadca89ddb95be5bd977 by GitHub (on behalf of Ziqing Luo) on 16/08/2026 at 01:04..
[SSAF][UnsafeBufferAnalysis] Filter out type-constrained pointers from reachable unsafe pointers (#209354)

Integrate the TypeConstrainedPointers analysis results into
UnsafeBufferReachableAnalysis. The final result is filtered to exclude
type-constrained pointers.

The pointer flow graph is untouched. Removing type-constrained pointers
from the graph would introduce unsoundness.

Final step for rdar://179151541 and rdar://179151882
https://invent.kde.org/qt/clang/llvm-project/-/commit/cbb56261423435e4e3d6dadca89ddb95be5bd977

Git commit 59d202c7711dabafafed4e408a50f46399322479 by GitHub (on behalf of Konstantinos Parasyris) on 16/08/2026 at 01:15..
[CIR][SYCL] Device kernel caller (#213771)

During device compilation, emit a SYCL kernel caller offload entry point
in
place of each function declared with the sycl_kernel_entry_point
attribute,
mirroring classic CodeGen's `CodeGenModule::EmitSYCLKernelCaller`.

Depends on #213728
https://invent.kde.org/qt/clang/llvm-project/-/commit/59d202c7711dabafafed4e408a50f46399322479

Git commit 503c01a127556d4c44171987599bd08ae78f2fc9 by GitHub (on behalf of Eric Christopher) on 16/08/2026 at 01:18..
[DebugInfo][NFC] Refactor debug record salvage (#215971)

Split address and variable-location salvage into helpers so the ordering
and the kill fallback stay visible in salvageDebugInfoForDbgValues, with the
variable-location helper returning whether it processed the record.
Rename the locals and parameters the move touches to say what they hold, and use
isAddressOfVariable() for the two #dbg_declare tests, which is the same
comparison.

Replace the address helper's single-use template with DbgVariableRecord
and pass it the instruction the caller already checked, rather than
recovering it with a dyn_cast the caller's check already covers.

Add a unit test for the dbg.assign address path.

No regressions on check-llvm or check-lldb; ran about 80 auto-generated C tests with 225ish locations and no differences in DW_AT_location on aarch64 at O2.

Assisted by AI.
https://invent.kde.org/qt/clang/llvm-project/-/commit/503c01a127556d4c44171987599bd08ae78f2fc9

Git commit be5ecb9efdb72b90dd713d4bb91c6a0c9322f4ca by GitHub (on behalf of Nico Weber) on 16/08/2026 at 01:37..
[gn] port 5f491a454cb8 (ABITests) (#216527)
https://invent.kde.org/qt/clang/llvm-project/-/commit/be5ecb9efdb72b90dd713d4bb91c6a0c9322f4ca

Git commit bfb662baf51dfc6e5c75b98c0f913cdbcbec96ad by GitHub (on behalf of flovent) on 16/08/2026 at 03:04..
[ASan] Register assert lit feature in `lit.cfg.py` (#216529)

Add this feature to test a functional change related to asserts, see
https://github.com/llvm/llvm-project/pull/213546#discussion_r3790705838.

And this will allow other people to add `// REQUIRES: asserts` in
testcases in the future too.

I follow the same pattern already used in `flang/test/lit.cfg.py` and
other configs.
https://invent.kde.org/qt/clang/llvm-project/-/commit/bfb662baf51dfc6e5c75b98c0f913cdbcbec96ad

Git commit 48030bdb606bdaba7e5bb0691243525453d8247b by GitHub (on behalf of Matt Arsenault) on 16/08/2026 at 06:55..
RISCV: Use m_GImplicitDef instead of getVRegDef + opcode check (#216514)

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

Git commit de0f427c97181fb35e128546f5ac0a39705c3541 by GitHub (on behalf of Matt Arsenault) on 16/08/2026 at 06:55..
GlobalISel: Use m_GImplicitDef instead of getVRegDef opcode checks (#216513)

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

Git commit b4c2e90feb2e504a44d7f3f7e25423c07ac34810 by GitHub (on behalf of Matt Arsenault) on 16/08/2026 at 06:58..
AArch64: Use MIPatternMatch in PostLegalizerCombiner ext checks (#216512)

Replace the getVRegDef + opcode-check idiom with mi_match. Add an
m_GSExtInReg matcher for G_SEXT_INREG, which has an extra immediate
operand and so does not fit the plain unary-op matcher shape.

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

Git commit 0b672437c396b700fdb94bd64b176b33f084053b by GitHub (on behalf of Oleksandr Tarasiuk) on 16/08/2026 at 07:46..
[Clang] Support friend declarations with a dependent nested-name-specifier (#208345)

Fixes https://github.com/llvm/llvm-project/issues/104057

---

This patch adds support for friend declarations with a dependent NNS
https://invent.kde.org/qt/clang/llvm-project/-/commit/0b672437c396b700fdb94bd64b176b33f084053b

Git commit 97ef3d4dcdda6116e4ec78683f1129626833ab54 by GitHub (on behalf of shalom) on 16/08/2026 at 08:15..
[InstCombine] Fold shl of constant by cttz into multiply of lowest set bit (#214517)

Currently, `C << cttz(X, true)` generates a DeBruijn lookup table on
RV64I (13 instructions).
And this patch adds a fold in InstCombine:
  `C << cttz(X, true)  -->  (-X & X) * C`
This reduces the instruction count from 13 to 3 on RV64I.
The fold requires that cttz has a single use (to avoid increasing
instruction count)

Alive2 proof: https://alive2.llvm.org/ce/z/TmWxrT
https://invent.kde.org/qt/clang/llvm-project/-/commit/97ef3d4dcdda6116e4ec78683f1129626833ab54

Git commit cbd8145859123b58a15e3d736e2e5e0b2d368569 by GitHub (on behalf of Hamza Qureshi) on 16/08/2026 at 08:49..
[MLIR][LLVM] Preserve pointer-valued metadata operands on import (#215743)

convertMetadataToAttrImpl only modelled ConstantInt operands wrapped in
a ConstantAsMetadata, so any metadata node containing a pointer constant
could not be represented and the whole node was rejected.

Add #llvm.md_null and #llvm.md_addrspacecast to model
ConstantPointerNull and addrspacecast constant expressions, keeping the
address space so that `ptr null` and `ptr addrspace(1) null` stay
distinct. MDAddrSpaceCastAttr verifies that its operand is itself
pointer-valued metadata.

Global values are constants, so ValueAsMetadata::get wraps them in a
ConstantAsMetadata and they never reached the ValueAsMetadata case.
Match them in the ConstantAsMetadata case instead, which also
generalizes the existing function-only handling to any named global
value and makes the addrspacecast operand representable.

Mirror both attributes in ModuleTranslation::convertMetadataAttr so the
original LLVM IR is reconstructed on export.

Fixes #215550

---------

Co-authored-by: Tobias Gysi <[email protected]>
https://invent.kde.org/qt/clang/llvm-project/-/commit/cbd8145859123b58a15e3d736e2e5e0b2d368569

Git commit f63a0e943131e8d05f6a7f68595fa6227afce54b by GitHub (on behalf of Timm Baeder) on 16/08/2026 at 09:02..
[clang][bytecode] Fix assertion failure in in valid continue stmt (#216547)

We need to handle the missing TargetLabel here, similarly to what we do
in break statements.
https://invent.kde.org/qt/clang/llvm-project/-/commit/f63a0e943131e8d05f6a7f68595fa6227afce54b

Git commit 8c64b15d0ecd3d443d0de15e96fc0237ece62e85 by GitHub (on behalf of hanbeom) on 16/08/2026 at 09:06..
[VectorCombine] Drop invariant.group from scalarized stores (#212473)

!invariant.group is tied to a pointer SSA value, so it cannot be copied
from a vector store to a scalar store that uses a newly created GEP.
Drop the metadata after copying the remaining store metadata and update
the regression expectations.

Fixes https://github.com/llvm/llvm-project/issues/212472

Assisted-by: Codex
https://invent.kde.org/qt/clang/llvm-project/-/commit/8c64b15d0ecd3d443d0de15e96fc0237ece62e85

Git commit 044118fdf22c9c3c77344a8c5a385accff81a575 by GitHub (on behalf of Oleksandr Tarasiuk) on 16/08/2026 at 09:29..
Revert "[Clang] Support friend declarations with a dependent nested-name-specifier" (#216549)

Reverts llvm/llvm-project#208345

---

Revert dependent friend support due to GCC build failure
https://invent.kde.org/qt/clang/llvm-project/-/commit/044118fdf22c9c3c77344a8c5a385accff81a575

Git commit e6b33964ac514f3f920b0c45d0c73b74a8ed2107 by GitHub (on behalf of Timm Baeder) on 16/08/2026 at 09:32..
[clang][bytecode] check reduce_min element type (#216536)

Only integer types are allowed.
https://invent.kde.org/qt/clang/llvm-project/-/commit/e6b33964ac514f3f920b0c45d0c73b74a8ed2107

Git commit ad7345a53718eefdda128d42cd6f79897ff34708 by GitHub (on behalf of Matt Arsenault) on 16/08/2026 at 10:24..
PeepholeOpt: Fix crash on copy from an undef register (#216539)
https://invent.kde.org/qt/clang/llvm-project/-/commit/ad7345a53718eefdda128d42cd6f79897ff34708

Git commit ee7f9bcf43f0f1adc7d98f23fe56e4331b508454 by GitHub (on behalf of Yao Qi) on 16/08/2026 at 10:25..
[lldb] Fix invalid UTF-8 in JSON log message (#216185)

Enabling the JSON packet log part way through a session aborts an
assertions build:

```
(lldb) b f
(lldb) run
(lldb) log enable -j -f /tmp/pk.json gdb-remote packets
(lldb) next
Assertion failed: (false && "Invalid UTF-8 in value used as JSON"), function Value, file JSON.h, line 333.
```

`Log::EmitJSONMessage` passed the message straight to
`llvm::json::Value`,
which asserts on ill-formed UTF-8 and only then falls back to `fixUTF8`.
So a release build repairs the message while an assertions build dies.

The bytes come from the saved packets.  Once logging is turned on,
`GDBRemoteCommunicationHistory::Dump` replays them verbatim, and the
reply
to an `x` (binary memory read) is binary:

```
history[80] tid=0x5c0f <  18> send packet: $x16fdfea00,200#f3
history[81] tid=0x5c0f < 516> read packet: $<binary>
```

The normal live packet path escapes binary before logging it, so this is
usually only seen when logging is enabled mid-session.
https://invent.kde.org/qt/clang/llvm-project/-/commit/ee7f9bcf43f0f1adc7d98f23fe56e4331b508454

Git commit 09e459b66b2967f09afeea5ba1dc7bf1e0a29b7f by GitHub (on behalf of Matt Arsenault) on 16/08/2026 at 10:38..
X86: Fix optimizeCompareInstr crash on a compare from an undef register (#216540)
https://invent.kde.org/qt/clang/llvm-project/-/commit/09e459b66b2967f09afeea5ba1dc7bf1e0a29b7f

Git commit df9a00dd1b80340f276e4850a1eab3e5c3619b16 by GitHub (on behalf of David Rivera) on 16/08/2026 at 11:09..
[CIR][NVPTX] Handle CUDALaunchBoundsAttr (#216447)

Source(s):
*
https://github.com/llvm/llvm-project/blob/34cce43ff1918e621ab08411fa7bc0e2ac4165b4/clang/lib/CodeGen/Targets/NVPTX.cpp#L242

*
https://github.com/llvm/llvm-project/blob/34cce43ff1918e621ab08411fa7bc0e2ac4165b4/clang/test/CodeGenCUDA/launch-bounds.cu#L4
https://invent.kde.org/qt/clang/llvm-project/-/commit/df9a00dd1b80340f276e4850a1eab3e5c3619b16

Git commit 2d70006c2a40ed35e6622c6cb38fa579d76c7777 by GitHub (on behalf of flovent) on 16/08/2026 at 11:27..
[ASan] Add xfail test for PR #213546 (#216532)

Add xfail test for PR #213546
https://invent.kde.org/qt/clang/llvm-project/-/commit/2d70006c2a40ed35e6622c6cb38fa579d76c7777

Git commit c27a08a38f758c7fbdbba3c77d4ccddefbb11517 by GitHub (on behalf of Nikolas Klauser) on 16/08/2026 at 11:38..
[libc++] Simplify the implementation of std::make_from_tuple (#215067)

This does two major things:
1) It removes conditionals for C++20/pre-C++20. I don't understand why
this has ever been done. This made the implementation significantly more
complicated without any indication that it actually improved anything.
2) std::apply is used for expanding the tuple
https://invent.kde.org/qt/clang/llvm-project/-/commit/c27a08a38f758c7fbdbba3c77d4ccddefbb11517

Git commit e65f3c155d9a957939ef63c1a824aa254a4cc20c by GitHub (on behalf of Nikolas Klauser) on 16/08/2026 at 11:38..
[Clang] Accept auto casts pre-C++23 as an extension (#200675)

GCC already supports this as an extension pre-C++23. It is also useful
for libc++ to replace `_LIBCPP_AUTO_CAST`.

Fixes #115609
https://invent.kde.org/qt/clang/llvm-project/-/commit/e65f3c155d9a957939ef63c1a824aa254a4cc20c

Git commit 860fcb7accb22e57a020a353a39f2fdbd0dc1b44 by GitHub (on behalf of Folkert de Vries) on 16/08/2026 at 12:17..
[Sparc][NFC] test sparc variadic aggregate handling (#216521)

equivalent of https://github.com/llvm/llvm-project/pull/216509 for
sparc. It similarly has some bugs passing aggregates with floats.
https://invent.kde.org/qt/clang/llvm-project/-/commit/860fcb7accb22e57a020a353a39f2fdbd0dc1b44

Git commit 4c5182e2fefda9dc48d0d4af473a2f316e6bb982 by GitHub (on behalf of vporpo) on 16/08/2026 at 13:18..
[SandboxVec][DAG][NFC] Replace UnscheduledSuccs/Preds with a single variable (#215364)

This is a cleanup patch that replaces the two DAG node unscheduled
dependency counters (that is UnscheduledSuccs and UnscheduledPreds) with
a single one named UnscheduledDeps.

The reasoning is that scheduling operates on one direction at a time so
if we are scheduling bottom-up then we only need the unscheduled
successors, and if we schedule top-down then we only need the
unscheduled predecessors.
https://invent.kde.org/qt/clang/llvm-project/-/commit/4c5182e2fefda9dc48d0d4af473a2f316e6bb982

Git commit 3d3203a2284bd7c439e5de8fe1bd0ab8135e7b31 by GitHub (on behalf of Sirui Mu) on 16/08/2026 at 13:53..
[CIR] Fold load from constant alloca slots (#212284)

This patch folds non-volatile non-atomic `cir.load` operation that loads
from a constant alloca slot into the initial value stored into that
slot, if the initialization dominates the load.

This effectively enables "constant folding" at the C/C++ language level.
Consider the following C/C++ source program:

```cpp
int g();
void use(int);

void h(const int *);   // <-- The body of h is external.
void f() {
  const int x = g();
  h(&x);
  use(x);
}
```

Since `h` is external, the LLVM optimizer cannot eliminate the load of
`x` before the call to the `use` function. This patch enables this
optimization by folding the load of `x` early on CIR.

PR #175037 has some prior discussions on this topic.

Assisted-by: codex / gpt-5.6 sol
https://invent.kde.org/qt/clang/llvm-project/-/commit/3d3203a2284bd7c439e5de8fe1bd0ab8135e7b31

Git commit 82b12a88a595ca735c0caf4558407150b3a02419 by GitHub (on behalf of Simon Pilgrim) on 16/08/2026 at 14:35..
[DAG] expandPEXT/PDEP - scalarize vector instructions if the scalar type is legal (#216567)

If the scalar instruction is legal, just unroll (scalarize) - similar to
what a lot of other generic expansions already do.

Helps x86/BMI2 targets at least for vXi32/i64 types - there's more we
can do to address vXi8/i16 types and slow-PDEP/PEXT cases (znver1/2
etc.) but they can be addressed later with x86 specific lowering after
we have the generic base in place.

Fixes #214508
https://invent.kde.org/qt/clang/llvm-project/-/commit/82b12a88a595ca735c0caf4558407150b3a02419

Git commit ea347c8d05fd4646990e678d0822920ee938239f by GitHub (on behalf of Kazu Hirata) on 16/08/2026 at 15:02..
[ADT] Remove bucket_begin, bucket_end, and FoldingSetBucketIterator (NFC) (#216548)

This patch removes bucket_begin, bucket_end, and the underlying
FoldingSetBucketIterator and FoldingSetBucketIteratorImpl classes in
FoldingSet.

These were added on February 4, 2008 in commit
e2887863563fe5d2fdd8e1219b76fdc1ee9ec37d for ImutAVLTree in
ImmutableSet.h.  The last use was removed on November 30, 2010 in commit
dbd89971ffb3a222dc91513585e8d6b5bc7882db when ImmutableSet switched
from FoldingSet to DenseSet.

Assisted-by: Antigravity
https://invent.kde.org/qt/clang/llvm-project/-/commit/ea347c8d05fd4646990e678d0822920ee938239f

Git commit f9f1170cb5960846e6f53a6492dc113c77745ebe by GitHub (on behalf of Dan Salvato) on 16/08/2026 at 15:36..
[M68k] Implement `SWAP` instruction encoding, patterns, and tests (#215597)
https://invent.kde.org/qt/clang/llvm-project/-/commit/f9f1170cb5960846e6f53a6492dc113c77745ebe

Git commit 6a2d309c7d204730a9a35f3261f8448efeb6c5e3 by GitHub (on behalf of Kenzo Tjandra) on 16/08/2026 at 16:16..
[Clang] Diagnose conflict between always_inline/noinline attributes (#215173)

This PR aims to diagnose `always_inline` and `noinline` conflicts which
currently could pass silently through `Sema` or cause a crash (with
assertions enabled). Changes include:

- Added `MutualExclusions<[AlwaysInline, NoInline]>` in `Attr.td`
- Prevent `always_inline` and `noinline` from being propagated from
generic to specialized templates in `SemaDecl.cpp`
- Prevent inner attributes from clobbering unrelated outer attributes
(e.g. `noinline` and `nomerge`) in both `CGStmt.cpp` and
`CIRGenStmt.cpp`

Something to consider though: Should we prevent propagating conflicting
attributes when doing explicit template specializations in general, not
just `inline`, e.g. `hot`/`cold`, `convergent`/`noconvergent`, etc.

Fixes #214764

---------

Co-authored-by: Erich Keane <[email protected]>
https://invent.kde.org/qt/clang/llvm-project/-/commit/6a2d309c7d204730a9a35f3261f8448efeb6c5e3

Git commit 65e0fe689bb7c1a6516644c27c25c3fe3c8b1ac7 by GitHub (on behalf of Orlando Cazalet-Hyams) on 16/08/2026 at 16:36..
[dyndbg][Clang] Implement nested-ELF dynamic debugging support (#216307)

Re-land https://github.com/llvm/llvm-project/pull/194860

A clone of the module is compiled without optimisations and embedded into the
to-be-optimised module using `embedBufferInModule`, similarly to how
`-ffat-lto-objects` and `-fembed-offload-object` work.

That unoptimised-code object is embedded in the optimised-code object in a
section called `.debug_llvm_dyndbg`.

The optimised ELF/module may be referred to as the "outer" ELF/module, and the
unoptimized one the "inner" ELF/module.

The outer module holds global data referred to by both modules and all calls in
the inner module are to outer module functions. To facilitate this the outer
module is modified, adding external-linkage aliases for local symbols.

For more detail see RFC https://discourse.llvm.org/t/90113 and documentation at
llvm/docs/DynamicDebugging.md.
https://invent.kde.org/qt/clang/llvm-project/-/commit/65e0fe689bb7c1a6516644c27c25c3fe3c8b1ac7

Git commit 55894238d869f03bb5b023f315d7fea4436f75fb by GitHub (on behalf of forking-google-bazel-bot[bot]) on 16/08/2026 at 16:39..
[Bazel] Fixes 1f4574c (#216346)

This fixes 1f4574c6033cae84c88ca69bb2b73c9b029925e3 (#216345).

Buildkite error link:
https://buildkite.com/llvm-project/upstream-bazel/builds?commit=1f4574c6033cae84c88ca69bb2b73c9b029925e3

Co-authored-by: Google Bazel Bot <[email protected]>
https://invent.kde.org/qt/clang/llvm-project/-/commit/55894238d869f03bb5b023f315d7fea4436f75fb

Git commit 30a31c467683a6c635d143848051160e9c8330be by GitHub (on behalf of Pavel Labath) on 16/08/2026 at 16:51..
[libc] Remove (weak) __cxa_thread_finalize (#216081)

Unlike __cxa_thread_atexit(_impl), this function is not a part of the
ABI as the process of calling the thread exit callbacks is an
implementation detail. Additionally, the weak definition gets in the way
of refactoring the thread code as the linker will not extract an object
from the archive if the dependency is already satisfied by a weak
definition.

Instead of a weak definition, I use a preprocessor macro to determine
whether we need to call the thread cleanup function (i.e., whether the
target supports threads).
https://invent.kde.org/qt/clang/llvm-project/-/commit/30a31c467683a6c635d143848051160e9c8330be

Git commit d2e52ee4783f48945bade69c0991fd69338a44b3 by GitHub (on behalf of Shivam Gupta) on 16/08/2026 at 18:37..
[clang][Lex] Preserve physical line start after comments in -C mode (#216556)

When comments are preserved with -C, a comment at the start of a
physical line consumes the PhysicalStartOfLine state. As a result, a
preprocessor directive following the comment is not recognized.

Preserve the PhysicalStartOfLine state when returning a comment token so
that directives following comments are still handled correctly.

Fixes: #48361
https://invent.kde.org/qt/clang/llvm-project/-/commit/d2e52ee4783f48945bade69c0991fd69338a44b3

Git commit d4e78d7f525f4e49b9d9df30139af5af56cdd91e by GitHub (on behalf of Erich Keane) on 16/08/2026 at 19:54..
[CIR] Allow non-power-of-2-popcount (#216440)

Found in running a test suite, _BitInt of a non-power of 2 wasn't
allowed in our cir.popcount operation, despite it lowering perfectly
fine into the LLVM instruction. This patch relaxes the limitation to any
size integer, and adds tests.

Note we have no tests >128 because we can't lay those out yet in memory,
and the tests use local variables instead of arguments because _BitInt
calling convention work isn't in place yet either.
https://invent.kde.org/qt/clang/llvm-project/-/commit/d4e78d7f525f4e49b9d9df30139af5af56cdd91e

Git commit 7cb5d896117ccd4142cd7a7bde284ea3392dd3b4 by GitHub (on behalf of Ziqing Luo) on 16/08/2026 at 19:59..
[SSAF][UnsafeBufferAnalysis] Do not create entries for empty contributors (follow-up change on #209354) (#216526)

Address follow up questions after the approval.

- The analysis should not create entries for empty contributors, which
otherwise is non-empty in the serialized format.
- use std IO instead of a tmp file for regex-ing FileCheck queries.

rdar://179151541 and rdar://179151882
https://invent.kde.org/qt/clang/llvm-project/-/commit/7cb5d896117ccd4142cd7a7bde284ea3392dd3b4

Git commit 2e78e25f3e5db4b634dd1daf95fea14b1db52c3a by GitHub (on behalf of Oleksandr Tarasiuk) on 16/08/2026 at 20:41..
[Clang] Support friend declarations with a dependent nested-name-specifier (#216555)

Fixes https://github.com/llvm/llvm-project/issues/104057

---

This patch adds support for friend declarations with a dependent NNS
https://invent.kde.org/qt/clang/llvm-project/-/commit/2e78e25f3e5db4b634dd1daf95fea14b1db52c3a

Git commit 89e98de49b198f8c8f94d87a75ee38fbd4223f38 by GitHub (on behalf of Hervé Poussineau) on 16/08/2026 at 20:50..
[LLD] Initial support for MIPS COFF relocations (#205200)

Base relocations are not handled, but it will be implemented later.
https://invent.kde.org/qt/clang/llvm-project/-/commit/89e98de49b198f8c8f94d87a75ee38fbd4223f38

Git commit 43c6d8a0e9ec06ee1efa3936d7ea3b50544b5ada by GitHub (on behalf of Dmitry Sidorov) on 16/08/2026 at 22:21..
[NFC][SLP] Add a mixed-reassoc bundle to the operand-1 fma test (#216594)

One lane carries reassoc and the other three do not, so the bundle is
only partly reassociative. Also add a second threshold to the run lines.
https://invent.kde.org/qt/clang/llvm-project/-/commit/43c6d8a0e9ec06ee1efa3936d7ea3b50544b5ada

Git commit c926bfd8069d46406603405ed01eb7e2d8362077 by GitHub (on behalf of Thurston Dang) on 16/08/2026 at 22:42..
[asan][test] Exclude invalid-pointer-pairs-vector-extract.cpp from Solaris (#216606)

Intended to fix buildbot breakage on Solaris (XPASS), as reported in
https://github.com/llvm/llvm-project/pull/216532#issuecomment-5309297518

This change is only a transient step for the test, since the upcoming
https://github.com/llvm/llvm-project/pull/213546 is expected to make the
test pass on all platforms.
https://invent.kde.org/qt/clang/llvm-project/-/commit/c926bfd8069d46406603405ed01eb7e2d8362077

Git commit 46b3a2b3b2c7640f3613cb4cec058c623bde7ca8 by GitHub (on behalf of Lang Hames) on 16/08/2026 at 23:00..
[orc-rt] Add StringPool for interning ref-counted strings. (#216571)

Adds StringPool, a thread-safe pool for interning strings (e.g. symbol
names, paths) behind ref-counted PooledStringPtr handles.
PooledStringPtr and NonOwningPooledStringPtr compare and hash by
pool-scoped pointer identity rather than content, and clearDeadEntries()
reclaims entries with no remaining owners.

No in-tree clients yet: I expect to use this in future commits for the
platform support classes.
https://invent.kde.org/qt/clang/llvm-project/-/commit/46b3a2b3b2c7640f3613cb4cec058c623bde7ca8

Git commit 15035c1d7932f7143f22a365435c6cede49738e0 by GitHub (on behalf of Lang Hames) on 16/08/2026 at 23:06..
[ORC] Fix and rename SymbolLookupSet::removeDuplicates (#216574)

removeDuplicates uniqued on the (name, flags) pair, so a name appearing
with both RequiredSymbol and WeaklyReferencedSymbol survived twice --
leaving a set that containsDuplicates, which compares names only, still
reported as duplicated.

Replace it with mergeEntries, which merges by name. Where entries
disagree on flags the strongest requirement wins, so a missing
definition still fails the lookup. Renamed because the entries being
merged need not be exact duplicates.

removeDuplicates had no in-tree callers, so no existing behaviour
changes. Also adds a unit test for mergeEntries -- the first direct
coverage for SymbolLookupSet.
https://invent.kde.org/qt/clang/llvm-project/-/commit/15035c1d7932f7143f22a365435c6cede49738e0

Git commit fd2eb9f5ef4950f8585455783bfcffb619d14447 by GitHub (on behalf of A. Jiang) on 16/08/2026 at 23:08..
[libc++][test] Mark `UNSUPPORTED` for a test relying on `[[clang::trivial_abi]]` for compilers not supporting it (#211736)

This patch marks `UNSUPPORTED` for compilers not supporting
`[[clang::trivial_abi]]` (MSVC and GCC earlier than GCC 17) for a test
relying on this attribute.
https://invent.kde.org/qt/clang/llvm-project/-/commit/fd2eb9f5ef4950f8585455783bfcffb619d14447

Git commit caa9864349da1be50c1a5375f61bf7f89d8ddf69 by GitHub (on behalf of Lang Hames) on 16/08/2026 at 23:38..
[orc-rt] Nest StringPool handle types (#216615)

Move the handle types into StringPool as nested members:

  PooledStringPtr          -> StringPool::Ptr
  NonOwningPooledStringPtr -> StringPool::WeakPtr
  PooledStringPtrBase      -> StringPool::PtrBase
  StringPoolEntryUnsafe    -> StringPool::EntryUnsafe

Also tightens the WeakPtr -> Ptr contract: reconstructing a Ptr is only
well-defined while another Ptr keeps the entry alive.
https://invent.kde.org/qt/clang/llvm-project/-/commit/caa9864349da1be50c1a5375f61bf7f89d8ddf69

Git commit 9e51d75e77c50e7ce5a10cfb82b0908f06008168 by GitHub (on behalf of Kazu Hirata) on 17/08/2026 at 00:39..
[ADT] Fix formatting in FoldingSet.* (NFC) (#216591)

I'm planning to work on FoldingSet.
https://invent.kde.org/qt/clang/llvm-project/-/commit/9e51d75e77c50e7ce5a10cfb82b0908f06008168

Git commit 391dd417e0864e2d1b50550e041e80b6a153a528 by GitHub (on behalf of oltolm) on 17/08/2026 at 00:43..
[compiler-rt] Clean up Windows includes in sanitizer runtimes (#216586)

Extracted from https://github.com/llvm/llvm-project/pull/209902.
It's one of the patches that enables ASan and UBSan in GCC for Windows.

Co-authored-by: Hannes Domani <[email protected]>
https://invent.kde.org/qt/clang/llvm-project/-/commit/391dd417e0864e2d1b50550e041e80b6a153a528

Git commit c31c334e11186d2c0b6a68a9f5619a4050cb87b7 by GitHub (on behalf of Hristo Hristov) on 17/08/2026 at 01:05..
[libc++][optional] LWG4497: `std::nullopt_t` should be comparable (#214975)

Implements https://wg21.link/LWG4497

Closes #189854

Also implements LWG4612: https://cplusplus.github.io/LWG/issue4612

---------

Co-authored-by: Mohamed Atef <[email protected]>
Co-authored-by: Hristo Hristov <[email protected]>
https://invent.kde.org/qt/clang/llvm-project/-/commit/c31c334e11186d2c0b6a68a9f5619a4050cb87b7

Git commit da522b4bb2af2f3a4ed96100dd95f8345e9d422b by GitHub (on behalf of Matt Arsenault) on 17/08/2026 at 02:15..
CodeGen: Fix lookThruCopyLike crash on an undef register (#216598)

Found by AI while working on something else.

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

Git commit d0b4c1bde99da365581a47ea12a2bed009692550 by GitHub (on behalf of Matt Arsenault) on 17/08/2026 at 02:15..
PowerPC: Fix FMA reassociation crash on an undef multiply operand (#216602)

Make sure getVRegDef succeeded.

Found by AI while working on something else.

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

Git commit 9cd4a3d4eeadf8f69b32f7b88bdcea480aab60ed by GitHub (on behalf of Erich Keane) on 17/08/2026 at 03:14..
[CIR] Fix the 'constant'-ness of vtable-variables (#216434)

The createOrReplaceCXXRuntimeVariable sets the variable to be 'constant'
in classic codegen, this sets that right. However, 1 use of it (in
buildVTablePointer) doesn't match classic-codegen (it instead calls
getOrInsertGlobal directly), so this patch adds a bit of a fixup there
to minimize the impact of this change.
https://invent.kde.org/qt/clang/llvm-project/-/commit/9cd4a3d4eeadf8f69b32f7b88bdcea480aab60ed

Git commit 3cc0457eb8f91ec655fbc0910a4852fbb3c0310f by GitHub (on behalf of Erich Keane) on 17/08/2026 at 03:14..
[CIR] Correct union lowering behavior re-padding (#216349)

Most of the code that CIR lowers to LLVM counts on the fact that our
alignnments are correct/calculated in LLVM to get our layout correctly.
This works for the most part, and unions have the storage type of the
'highest' alignment type.

However, when creating a constant, we have to convert the type of the
union to have a 'storage' type that matches the data being inserted (not
the union's storage type!). The result was that if we had a storage type
where the alignment was smaller than the actual storage type, LLVM would
mis-calculate the padding.

This patch adds the padding explicitly when we make that conversion to
get the alignment set up correctly.

Note: there is one mild IR-equivilency-regression to this patch. There
isn't really a great way to tell the difference between a
union-tail-padding needing zero-init vs undef-init in this case. This
patch chooses to make it always zero-init, which is harmless. While it
MIGHT suppress some optimizations (facts not in evidence?), it seems
like something we can figure out later if necessary.
https://invent.kde.org/qt/clang/llvm-project/-/commit/3cc0457eb8f91ec655fbc0910a4852fbb3c0310f

Git commit ddba329a3e54c349533dbefbae92513f4d20a638 by GitHub (on behalf of Kazu Hirata) on 17/08/2026 at 03:29..
[ADT] Clean up FoldingSet.* (NFC) (#216619)

This patch cleans up minor issues in FoldingSet.*.

- FoldingSetBase::NodeID never existed in the history of FoldingSet.
  The comment should refer to FoldingSetNodeID instead.

- GetBucketPtr lost the first line of its doc comment on February 4,
  2008 in commit e2887863563f, leaving only "testing.".

- ImmutableSetTest.cpp was relying on FoldingSet.h to include
  ArrayRef.h.

Other changes should be self-explanatory.

Assisted-by: Antigravity
https://invent.kde.org/qt/clang/llvm-project/-/commit/ddba329a3e54c349533dbefbae92513f4d20a638

Git commit 77bdc160b4ae80a4a887e927afb2934a6b417d41 by GitHub (on behalf of Thurston Dang) on 17/08/2026 at 03:56..
[dyndbg][Clang] Avoid memcpy on nullptr from #216307 (#216625)

As reported in
https://github.com/llvm/llvm-project/pull/216307#issuecomment-5311023374,
the new tests fail on UBSan buildbots (e.g.,
https://lab.llvm.org/buildbot/#/builders/25/builds/19323) because the
directory may be empty (only the file is initialized [*]). The StringRef
from getDirectory() would be default-initialized, and hashing it results
in memcpy'ing from a null pointer.

This patch attempts to fix-forward by not hashing the output of
getDirectory() if it is empty.

[*] e.g., `!3 = !DIFile(filename:
"/usr/local/google/home/thurston/llvm-projectA/clang/test/DebugInfo/DynamicDebugging/<stdin>",
directory: "")`
https://invent.kde.org/qt/clang/llvm-project/-/commit/77bdc160b4ae80a4a887e927afb2934a6b417d41

Git commit d04e49d9abec1cc705f92f205571712752f95b4a by GitHub (on behalf of Twice) on 17/08/2026 at 04:00..
[MLIR][CAPI][Python] Add support for querying memory effect instances (#213459)

The current memory-effect bindings are write-only. Python interface
implementations can append effects to a temporary
`MemoryEffectInstancesList`, but callers cannot inspect an effect
instance or ask an operation for its effects.

This patch adds the missing query support to the C API and exposes it in
Python. Effect instances can be inspected and copied, and the Python
APIs use regular `MemoryEffectInstance` objects and Python-native
`list`s. The Transform helpers follow the same model.

`MemoryEffectInstancesList` is **removed** from both the C and Python
APIs. Python implementations and helpers now return effects instead of
mutating a supplied list, while the C API passes effects through
callbacks (`MlirMemoryEffectInstancesCallback`).

When an API produces a batch of effects, it invokes
`MlirMemoryEffectInstancesCallback` with a count and an array. The
instances remain valid until the callback returns; the callback may
inspect them synchronously or clone the instances it needs to keep and
destroy those clones later. `userData` lets language bindings collect
the clones into their native sequence type. APIs consuming a batch use
count-and-array parameters directly.

This is a **breaking change**. The migration is limited to replacing
output parameters with return values or callbacks.

Related to #210586 and #176920.

Assited by: Codex / GPT 5.6 Sol

---------

Co-authored-by: Rolf Morel <[email protected]>
https://invent.kde.org/qt/clang/llvm-project/-/commit/d04e49d9abec1cc705f92f205571712752f95b4a

Git commit d2028c30be01d0f358bfb576a68cac2b0bc94c7e by GitHub (on behalf of renndong) on 17/08/2026 at 04:34..
[TableGen] Add checks for CheckRegOperand/CheckImmOperand (#215230)

`CheckRegOperand`, `CheckImmOperand`, and their related predicates
currently call `getReg()` and `getImm()` without first verifying that
the operand is a register or an immediate. Users must explicitly use
`CheckIsRegOperand` and `CheckIsImmOperand` to avoid errors for other
operand kinds, as exposed by #213815.

This PR adds default `isReg()` and `isImm()` checks to those predicates
before accessing the corresponding values, and also removes redundant
`CheckIsRegOperand` and `CheckIsImmOperand` checks from existing users
in the X86, ARM, and RISCV backends.
https://invent.kde.org/qt/clang/llvm-project/-/commit/d2028c30be01d0f358bfb576a68cac2b0bc94c7e

Git commit 6a114fb6e507267103d10fd6f180327b717213be by GitHub (on behalf of Lang Hames) on 17/08/2026 at 04:41..
[ORC] Extend SymbolLookupSet unit test coverage (#216617)

Covers the rest of the public API: construction, add/append, remove,
remove_if, forEachWithRemoval, getSymbolNames, sortByName, sortByAddress
and containsDuplicates.
https://invent.kde.org/qt/clang/llvm-project/-/commit/6a114fb6e507267103d10fd6f180327b717213be

Git commit 2b5f97068fa15083295cd5d37a1a0d4d01396026 by GitHub (on behalf of Craig Topper) on 17/08/2026 at 04:41..
[RISCV] Move -mtune=native expansion into riscv::getRISCVTuneCPU. NFC (#215891)

Previously it was applied at one of the call sites. Applying it inside
makes it more clear how it is supposed to interact with
-mexperimental-mtune-syntax
https://invent.kde.org/qt/clang/llvm-project/-/commit/2b5f97068fa15083295cd5d37a1a0d4d01396026

Git commit 351d8690af57ad553284106d812b86e0ac896e90 by GitHub (on behalf of mbhade-amd) on 17/08/2026 at 04:45..
[X86][CostModel] Free a clean narrow zext used as a GEP index (#216256)

`getCastInstrCost` already treats a narrow (i8/i16) zext of a load as
free (the extension folds into the load). This extends the same
movzx-free reasoning to any narrow zext whose single use is a **GEP
index** with a provably-clean source — a load, a `zeroext` argument, or
known-zero high bits. On x86-64 `[base + index*scale + disp]` reads the
index at full width, so a clean narrow index needs no `movzx`. A dirty
source (e.g. an `i16 add` used only as an index) still needs one and is
unchanged. The cost is consumed by SimplifyCFG's two-entry-PHI fold
budget (`TCK_SizeAndLatency`); overcharging a clean index by one kept
small select diamonds branched on x86.

Test: `llvm/test/Analysis/CostModel/X86/zext-gep-index.ll` — fails on
trunk
(clean known-bits index reports 1), passes with the patch.

---------

Co-authored-by: Cursor <[email protected]>
https://invent.kde.org/qt/clang/llvm-project/-/commit/351d8690af57ad553284106d812b86e0ac896e90

Git commit 14c9bb98d432033a40c823c34681937af8564989 by GitHub (on behalf of TelGome) on 17/08/2026 at 05:15..
[RISCV][P-ext] Support Packed Narrowing Clip Pair (#215779)
https://invent.kde.org/qt/clang/llvm-project/-/commit/14c9bb98d432033a40c823c34681937af8564989

Git commit 38da688c60b208a48d60b70396ac46716edc72d5 by GitHub (on behalf of Matt Arsenault) on 17/08/2026 at 05:46..
RISCV: Fix optimizeCondBranch crash on an undef register (#216633)

Found by AI while working on something else.

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

Git commit 8a34f9d127e52586c7285fa07efd1b6b8e428ca0 by GitHub (on behalf of David Green) on 17/08/2026 at 06:26..
[DAGCombine][AArch64][X86] Adjust profitability check on and(anyext, c) -> zext(and) transform (#214749)

This existing fold was using a profitability check that did not work for
vector operations. It can be profitable to fold (and (anyext V), c) ->
(zext (and V, c)) if it allows the And to work on a narrower type and
possibly for the zext to be folded into other operations.

The combine is profitable or equal if the zext is the same cost as a
anyext. The old isTruncFree was removed as the value being truncated is
a constant. A basic version of isNarrowingProfitable is added for
AArch64 to allow vector types to fold providing that the result type is
legal and a isAnyExtFree method is added for the anyext cost.
https://invent.kde.org/qt/clang/llvm-project/-/commit/8a34f9d127e52586c7285fa07efd1b6b8e428ca0

Git commit a6d40b40c42d95963f915234851855f456a55b53 by GitHub (on behalf of Robert Imschweiler) on 17/08/2026 at 07:22..
[libomp] Fix hang when a fatal error is raised before library registration (#215988)

Uncovered by debug-build testing, not triggered for non-debug builds due
to absence of KMP_DEBUG_ASSERT.

Claude assisted with this patch.
https://invent.kde.org/qt/clang/llvm-project/-/commit/a6d40b40c42d95963f915234851855f456a55b53

Git commit 2eeb5f10ff28b514000831c8afe6b9dab999952e by GitHub (on behalf of Yao Qi) on 17/08/2026 at 07:49..
[lldb] Gate debugserver tests on advertised qSupported features (#214768)

Tests that need a recent `debugserver` skipped themselves with
`@skipIfOutOfTreeDebugserver`, which asks whether the stub was built in
the tree
rather than whether it supports the feature under test. A system
`debugserver`
that already ships the feature was skipped anyway, and a stale in-tree
build was
not.  Every year, we remove some `@skipIfOutOfTreeDebugserver` because
the new feature shipped in system `debugserver`.

Ask the stub instead.  Tests get the supported features of stub, and
only run the test if stub advertises the very feature.

`TestConsecutiveWatchpoints` keeps the decorator, because it covers a
`debugserver`
bug fix that no capability describes and it also runs against
`lldb-server`.

A stub without the feature can never run the test, so the reason is an
`UnsupportedReason` and the result is `UNSUPPORTED` rather than
`SKIPPED`. Against
a system `debugserver`, the gated test in `TestExpeditedStackMemory.py`
used to
report

```
SKIPPED: ... test_memory_reads_when_examining_frame0_locals (out-of-tree debugserver)
Skip breakdown (unsupported=0, skipped=1)
```

and now reports

```
UNSUPPORTED: ... test_memory_reads_when_examining_frame0_locals (stub does not support ExpediteStack+)
Skip breakdown (unsupported=1, skipped=0)
```

These are the first skips decided while the test is running, and a
reason raised
from a test body reaches the result as `str(exception)`, which drops the
`UnsupportedReason` type. `Base.skipTest` therefore records the
distinction on
the test, and `is_unsupported()` accepts it from either source: the
reason object
for a `require*` decorator, the test for a runtime skip.
https://invent.kde.org/qt/clang/llvm-project/-/commit/2eeb5f10ff28b514000831c8afe6b9dab999952e

Git commit 83fc40a59dd97fcde13c18aa08b9ef940b97a22e by GitHub (on behalf of Matt Arsenault) on 17/08/2026 at 08:07..
AArch64: Fix optimizeCondBranch crash on an undef register (#216593)

Found by AI while working on something else.

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

Git commit bcbe2e2dbc6c5ee44536aff93579fa0d8d7ed34f by GitHub (on behalf of Luke Hutton) on 17/08/2026 at 08:37..
[mlir][tosa] Add option to validate function signature during validation (#214276)

This commit adds a new option to the TOSA validation pass,
"validate-function-signature", which allows users to specify whether the
function signature should be checked with respect to: use of tensor
types (tosa.shape types are not supported at function boundaries),
supported data types (currently there is no consideration for the loaded
profiles/extensions) and the shape of tensor arguments/return types.
https://invent.kde.org/qt/clang/llvm-project/-/commit/bcbe2e2dbc6c5ee44536aff93579fa0d8d7ed34f

Git commit 3ea0b52258cbe94abcdf3ff57bfd7f4d6a93016c by GitHub (on behalf of Jianjian Guan) on 17/08/2026 at 08:45..
[CIR][RISCV] Support Zknd builtins (#212947)
https://invent.kde.org/qt/clang/llvm-project/-/commit/3ea0b52258cbe94abcdf3ff57bfd7f4d6a93016c

Git commit 93ebddedab9833af230754ab49f5b642a02f36e6 by GitHub (on behalf of Orlando Cazalet-Hyams) on 17/08/2026 at 08:56..
[dyndbg][nfc] use -emit-llvm-only in coverage test (#216662)

Follow-up to https://github.com/llvm/llvm-project/pull/216307
https://invent.kde.org/qt/clang/llvm-project/-/commit/93ebddedab9833af230754ab49f5b642a02f36e6

Git commit 39440565ffd98a811f2e17086494a5d28d36ac28 by GitHub (on behalf of Frank Schlimbach) on 17/08/2026 at 09:07..
[mlir][gpu] Fix L0_SAFE_CALL in LevelZero runtime (#215308)

Using NULL as `RTContext` can lead to crashes when calling
`zeDriverGetLastErrorDescription`.
Now using `getRtContext()` instead.
https://invent.kde.org/qt/clang/llvm-project/-/commit/39440565ffd98a811f2e17086494a5d28d36ac28

Git commit 79679be4d194bf28f25e93d2782384cd7f2606b5 by GitHub (on behalf of Srinivasa Ravi) on 17/08/2026 at 09:11..
[MLIR][NVVM] Add asynchronous store Ops (#210931)

This change adds the `store.async.global` and `store.async.shared`
ops to the NVVM dialect to perform asynchronous stores to global
or shared-cluster address spaces.

PTX Spec References:
1.
[`st.async`](https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#data-movement-and-conversion-instructions-st-async)
2.
[`multimem.st.async`](https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#data-movement-and-conversion-instructions-multimem-st-async)
https://invent.kde.org/qt/clang/llvm-project/-/commit/79679be4d194bf28f25e93d2782384cd7f2606b5

Git commit 898b0188d9016c310629e53383c56365f6ee861a by GitHub (on behalf of Hung Kuan Tseng) on 17/08/2026 at 09:21..
[APFloat] Report the sign and the zero a conversion cannot represent (#216056)

`APFloat::convert` reports through `losesInfo` what rounding lost, but
not what
the target format has no encoding for at all. Two properties of a format
are not
rounding:

| property | formats today | what happens |
|---|---|---|
| `hasSignedRepr == false` | `f8E8M0FNU`, `f8E5M3FNU` | the sign bit is
carried into a format with no room for it |
| `hasZero == false` | `f8E8M0FNU` | zero is replaced by the smallest
normalized value, 2^-127 |

Both were reported as `opOK` with `losesInfo == false`. Callers gate on
`losesInfo` -- that is how `arith.truncf`'s folder decides whether a
constant
fold is legal -- so they kept a value the format cannot hold.

### What went wrong in MLIR

```mlir
%c = arith.constant -2.000000e+00 : f32
%t = arith.truncf %c : f32 to f8E8M0FNU    // --canonicalize
```

folded, and printing the folded constant reached `convertFromString`,
whose
leading-minus path is an `llvm_unreachable`:

```
This floating point format does not support signed values
UNREACHABLE executed at llvm/lib/Support/APFloat.cpp:3190!
```

The zero case did not crash, it disagreed: the folder produced 2^-127,
while
`--arith-expand=include-f8e8m0` reads the same `0x00` encoding back as
`0.0`.

### The two commits

1. **`APFloat`**: report both as `opInexact` with `losesInfo` set. The
values
that come out are unchanged, only the status is. The NaN path is
restructured
to fall through to the common tail instead of returning early, so the
checks
see every conversion. `arith.truncf` then leaves both constants alone.

2. **MLIR parser**: `arith.constant -2.000000e+00 : f8E8M0FNU` needs no
pass at
all -- parsing and printing the file was enough to assert, because the
attribute is built with `FloatAttr::get` and never consults `losesInfo`.
Both
   literal paths now emit a diagnostic:

   ```
error: negative floating point literal for a type with no signed
representation
   ```

### One test changed on purpose

`APFloatTest.ConvertDoubleToE8M0FNU` pinned the old status for the zero
case:

```cpp
  // For E8M0, zero encoding is represented as the smallest normalized value.
  EXPECT_FALSE(losesInfo);
  EXPECT_EQ(status, APFloat::opOK);
```

The substituted value is kept -- only the two lines above change, since
2^-127
is not the value that went in. Please say if that substitution is meant
to be
reported as exact; everything else here follows from it.

### Not covered

Writing `0.0 : f8E8M0FNU` as a literal still yields 2^-127 silently.
That is a
value question rather than a crash, and rejecting the literal is a
bigger
decision than this patch should take; the folder no longer produces it.

### Verification

| check | result |
|---|---|
| `ADTTests` | 2188 passed, 0 failed |
| `check-mlir` | 3848 passed, 0 failed (611 unsupported, 1 expectedly
failed) |
| `git clang-format` | clean |

Both reproducers from the issue were rerun: the fold is gone (`-2.0` and
`0.0`
into `f8E8M0FNU`, and `-2.0` into `f8E5M3FNU` all stay as
`arith.truncf`), and
the literal now produces a diagnostic instead of an abort.

Fixes #215445
https://invent.kde.org/qt/clang/llvm-project/-/commit/898b0188d9016c310629e53383c56365f6ee861a

Git commit 988e509161d498930869e639698d948827aeadbd by GitHub (on behalf of Lewis Crawford) on 17/08/2026 at 09:21..
[libc] Fix FreeBSD build for 53-bit-rounded fp80s (#216332)

Fix build issues on FreeBSD, which reports `LDBL_MANT_DIG == 53` for
`long double` on some targets despite using fp80 as the underlying type.
This is because it stores the value as an fp80, but configures the FPU
to round the mantissa to 53-bits. However, this causes some parts of
libc to misidentify the fp80 as an fp64 since both use a 53-bit
mantissa. This led to build issues on FreeBSD when trying to bitcast the
12-byte `FPBits<long double>` to an 8-byte fp64 value.

This is fixed by checking both the mantissa size and the exponent range
when determining the correct format for `long double`. Also, move the
check for this to a single place in `types.h`, rather than re-checking
the `LDBL_MANT_DIG` and `LDBL_MAX_EXP` values in `FPBits.h`.
https://invent.kde.org/qt/clang/llvm-project/-/commit/988e509161d498930869e639698d948827aeadbd

Git commit c8a046091804e7fdf3b58fe75bd47976b1ef2f9a by GitHub (on behalf of Andrzej Warzyński) on 17/08/2026 at 09:24..
[mlir] Filter out failing tests when expensive checks are ON (#216323)

Adds logic to conditionally disable tests that fail when expensive
checks are enabled,
*  -DMLIR_ENABLE_EXPENSIVE_PATTERN_API_CHECKS=ON. 

When the expensive API checks are disabled, the newly marked tests
are run as usual.

This is a temporary measure to enable the introduction of a buildbot
that will run with expensive API checks enabled. No new tests disabled with
expensive checks should be added, i.e. tests with 
 * `XFAIL: mlir-expensive-checks`.
 
The existing failures marked in this PR should be fixed.

GitHub issue that reported these failures prior to this PR:
  * https://github.com/llvm/llvm-project/issues/163599
https://invent.kde.org/qt/clang/llvm-project/-/commit/c8a046091804e7fdf3b58fe75bd47976b1ef2f9a

Git commit 952515a290d3c9d239fadf3f28c1d0f19170bbd7 by GitHub (on behalf of Sergio Afonso) on 17/08/2026 at 09:28..
[Flang][OpenMP] Prevent allocate directive ICE on module variables (#216021)

The current lowering implementation for `allocate` directives assumes
the MLIR function in which it is creating operations will still be there
by finalization time, so that it can add a deallocation call.

When lowering Fortran modules, this is not the case (lowering happens in
a temporary dummy function) and it results in a compiler crash while
running cleanup callbacks. This patch adds a TODO for this case.
https://invent.kde.org/qt/clang/llvm-project/-/commit/952515a290d3c9d239fadf3f28c1d0f19170bbd7

Git commit 4593ff73d0878f29b06c0d8fbc7f2ef2970f806a by GitHub (on behalf of Sergei Druzhkov) on 17/08/2026 at 09:28..
[lldb-dap] Preserve watchpoints from console (#215228)

We should not delete watchpoints created via LLDB console when
processing DAP `setDataBreakpoints` request.
https://invent.kde.org/qt/clang/llvm-project/-/commit/4593ff73d0878f29b06c0d8fbc7f2ef2970f806a

Git commit 07e3a4e43ffd0147f88ba581cffd8e3904393bb5 by GitHub (on behalf of Matt Arsenault) on 17/08/2026 at 09:32..
GlobalISel: Introduce m_GPtrAdd flags matcher in CombinerHelper (#216600)

Add an optional MIFlags output operand to the binary-op matcher and a
m_GPtrAdd(L, R, m_MIFlags(F)) overload, and use it to replace getVRegDef
+ opcode checks.

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

Git commit 24045beb3d9bbc62cfeaa5b42b23376c0e2ff73a by GitHub (on behalf of David Spickett) on 17/08/2026 at 09:41..
[lldb] Fix GetIndexOfChildWithName and GetChildMemberWithName on register sets (#212727)

And GetChildMemberWithName which had the same issue.

Fixes #211787.

Both of these methods were doing a lookup on the register info array as
a whole, rather than the subset of indexes into that array. That subset
of indexes is the "register set".

This lead to problems like this where index and name getters disagreed:
```
>>> lldb.frame.GetRegisters()[1].GetChildAtIndex(0)
(unsigned char __attribute__((ext_vector_type(16)))) v0 = (0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f,
 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f)
>>> lldb.frame.GetRegisters()[1].GetIndexOfChildWithName("v0")
63
```
GetChildAtIndex told us that v0 was at index 0, but looking up v0 by
name tells us it's at index 63. And it meant you could get a register
using ChildMemberWithName on a register set that did not contain the
register. For example get v0 (floating point) via the general purpose
register set (which does not contain v0).

To fix this I've changed both to look through only the register infos of
the registers within the set. This exposed some problems in existing
tests, which I've fixed and I've added a full test that checks the two
methods agree with each other.

That test is not checking the literal values (the integer values)
between registers because:
* Overlapping register names is very unlikely, so we are unlikely to
make a mistake with the values.
* Some registers have different types (floating point/vector and so on)
and I didn't want to complicate the test with N different comparison
functions.
* Keeping the test high level means it can run anywhere. Aside from the
alias check, which has to be target specific.
https://invent.kde.org/qt/clang/llvm-project/-/commit/24045beb3d9bbc62cfeaa5b42b23376c0e2ff73a

Git commit 184f413181a81a90f2c5d9ec52c8bbba1ec521c6 by GitHub (on behalf of Akimasa Watanuki) on 17/08/2026 at 09:42..
[mlir][affine] Require a vector size in affine-super-vectorize (#171110)

Diagnose invocations that omit the `virtual-vector-size` option. A
vector rank is required to construct a vectorization pattern, so
accepting an empty size list would silently leave the input unchanged.

Check that vector sizes are present and positive before applying
rank-dependent constraints.

Fixes #114528
https://invent.kde.org/qt/clang/llvm-project/-/commit/184f413181a81a90f2c5d9ec52c8bbba1ec521c6

Git commit cfd277e2eff7ee8b9740481c0ded3caa4c5b1d7d by GitHub (on behalf of Andrzej Warzyński) on 17/08/2026 at 09:46..
[clang][CIR][AArch64] Add lowering for conversion intrinsics (#211609)

This PR adds lowering for intrinsic from the following groups:
* https://arm-software.github.io/acle/neon_intrinsics/advsimd.html#conversions

It continues the work started in #190961, #193273, #199990 and #209252.
This PR implements the remaining conversions truncating to zero:
  * vcvts_s32_f32
  * vcvts_s64_f32
  * vcvts_u32_f32
  * vcvts_u64_f32

The corresponding tests are moved from:
  * clang/test/CodeGen/AArch64/

to:
  * clang/test/CodeGen/AArch64/neon/

The lowering follows the existing implementation in
CodeGen/TargetBuiltins/ARM.cpp
https://invent.kde.org/qt/clang/llvm-project/-/commit/cfd277e2eff7ee8b9740481c0ded3caa4c5b1d7d

Git commit 9d81ccaf02ac2696f3912925e5145ee66110450f by GitHub (on behalf of Arun Thangamani) on 17/08/2026 at 09:56..
[mlir][x86] Fix - Instrincs selection for hf8 and bf8. (#216647)

This patch fixes the error instrincs selection for `bf8` and `hf8`
types.

- Intel AMX naming: `bf8 == E5M2`, `hf8 == E4M3FN`.
https://invent.kde.org/qt/clang/llvm-project/-/commit/9d81ccaf02ac2696f3912925e5145ee66110450f

Git commit 746a3438ce0c68f508b320433e665b7178f541ca by GitHub (on behalf of Pavel Labath) on 17/08/2026 at 09:59..
[libc] Fix {asc,c,gm,mk}time(_r)? tests and spurios snprintf call (#216423)

time_test_utils was depending on a non-existent library, which caused
these tests to be auto-skipped. Fixing that exposed the fact that some
of the tests don't build (in hermetic mode) due to a snprintf
dependency concealed behind a __builtin_snprintf in asctime.

This patch addresses the existing TODO by moving
asctime to asctime_utils.h (avoiding a dependency loop)
and implementing it via strftime_main.

Assisted by Gemini.
https://invent.kde.org/qt/clang/llvm-project/-/commit/746a3438ce0c68f508b320433e665b7178f541ca

Git commit b834b9eb8349dab7e2cc0d6511853b4efe158091 by GitHub (on behalf of Chris Copeland) on 17/08/2026 at 10:05..
[ARM] Emit an error when the hard-float ABI is enabled but can't be used (#111334)

Prior to this, compiling for an eabihf target with a CPU lacking
floating-point registers would silently use the soft-float ABI instead,
even though the Arm attributes section would still have
"Tag_ABI_VFP_args: VFP registers", which leads to silent ABI mismatches
at link time.

Update various tests that were using inconsistent ABI/PCS and features.

Change ARMTargetLowering::getEffectiveCallingConv from private to public
and modify it to pass through unrecognized calling conventions. Now that
ARMBaseTargetMachine::createMachineFunctionInfo calls it, leaving a
fatal error would change the behavior of IR passes that do not need to
lower calling conventions. Unrecognized calling conventions are still
treated as errors in lowering.

Fixes #110383.
https://invent.kde.org/qt/clang/llvm-project/-/commit/b834b9eb8349dab7e2cc0d6511853b4efe158091

Git commit 378f2d88e32147459b24d63b971711136f83c0b0 by GitHub (on behalf of Jiang Ning) on 17/08/2026 at 10:05..
[AArch64][BOLT] Fold local-exec TLS relocations into loads and stores (#215531)

Emit the low part of the 12- and 24-bit local-exec sequences as an
ADDlow so that it folds into the addressing mode of a following load or
store, saving one instruction.

This re-lands the local-exec part of r327316 (7bc64bd889ad), whose ELF
changes r327503 (bde677289acc) reverted because neither LLD nor GNU
binutils implemented the relevant
R_AARCH64_TLSLE_LDST*_TPREL_LO12 relocations at the time.

LLD and GNU bfd now handle the non-checking 8- to 64-bit variants used
by the default 24-bit sequence. GNU bfd also handles the checked
variants used by the 12-bit sequence; LLD does not support those, but it
did not support the predecessor checked ADD relocation either. GNU bfd
still has no LDST128 support, so 128-bit accesses stay unfolded.

Teach BOLT to classify the folded TLS load/store relocations so it can
process binaries linked with --emit-relocs.
https://invent.kde.org/qt/clang/llvm-project/-/commit/378f2d88e32147459b24d63b971711136f83c0b0

Git commit f7c03ecb953298eac9a33dbc787877c6205ad28d by GitHub (on behalf of Arseniy Obolenskiy) on 17/08/2026 at 10:12..
[AMDGPU] Fix isKnownNeverNaN for FMIN_LEGACY/FMAX_LEGACY (#216338)

These compare-selects return one of the operands bit-for-bit, so a
signaling NaN operand passes through unquieted

Recurse into both operands instead of assuming never-sNaN
https://invent.kde.org/qt/clang/llvm-project/-/commit/f7c03ecb953298eac9a33dbc787877c6205ad28d

Git commit 4487de6d50f331b31cde0eb747ae54b496f3755e by GitHub (on behalf of Matt Arsenault) on 17/08/2026 at 10:14..
RuntimeLibcalls: Provide fp128 long double libcalls on X86 (#216622)

16a8d8d038a3  removed the l-suffixed long double math functions
from the default set and re-added them per-target gated on
isLongDoubleF128, but X86 was not given the re-add. On targets
whose long double is fp128 (e.g. x86_64 Android/OHOS) this dropped
the fp128 l-suffixed libcalls.

Fixes the regression reported on #214944.

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

Git commit 35aea1d041235a0e5d851dd02858b4f10858d22b by GitHub (on behalf of Matt Arsenault) on 17/08/2026 at 10:23..
GlobalISel: Use MIPatternMatch in GIMatchTableExecutor (#216601)

Replace the getVRegDef + opcode-check idiom in isBaseWithConstantOffset
with mi_match using m_GPtrAdd and m_GConstant.

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

Git commit a14f953e22f6eb2468645a478827be2ea1b63c8e by GitHub (on behalf of Kashika Akhouri) on 17/08/2026 at 10:25..
Support [[clang::lifetime_capture_by(X)]] in Plain Containers  (#204361)

This PR implements support for `[[clang::lifetime_capture_by(X)]]` to
enable tracking lifetimes for plain structs and containers like
`std::vector` without requiring manual `[[gsl::Pointer]]` or
`[[gsl::Owner]]` annotations. The implementation extends the
`LifetimeAnnotatedOriginTypeCollector` to register types in capture_by
contracts for origin tracking.

This PR also enables the intra-procedural analysis in existing tests
using -Wlifetime-safety and updated expectations to handle the more
detailed flow-sensitive diagnostics.

```cpp
struct MyContainer {
  const char* stored_ptr;
};

void captureInto(std::string_view v [[clang::lifetime_capture_by(c)]], MyContainer& c);

void test_parameter_capture() {
  MyContainer container;
  {
    std::string local = "temporary data";
    captureInto(local, container); 
  }
  (void)container;
}
```

Warnings Generated:
```cpp
b10.cpp:14:17: warning: local variable 'local' does not live long enough [-Wlifetime-safety-use-after-scope]
   14 |     captureInto(local, container); 
      |                 ^~~~~
b10.cpp:15:3: note: destroyed here
   15 |   }
      |   ^
b10.cpp:16:9: note: later used here
   16 |   (void)container;
      |         ^~~~~~~~~
```
https://invent.kde.org/qt/clang/llvm-project/-/commit/a14f953e22f6eb2468645a478827be2ea1b63c8e

Git commit 98ae570624dea48695e7f619602510a130e434f0 by GitHub (on behalf of Florian Hahn) on 17/08/2026 at 10:27..
[VPlan] Remove the unused CalculateTripCountMinusVF opcode (NFC) (#216675)

bcc272b3220f ("[LV] Remove DataAndControlFlowWithoutRuntimeCheck. NFC",
#183762) removed the only createNaryOp building this opcode, leaving
behind the enum entry and its cases for type inference, operand count,
scalar generation, lowering and printing. Nothing constructs it, so no
plan can contain it and no test prints it.
https://invent.kde.org/qt/clang/llvm-project/-/commit/98ae570624dea48695e7f619602510a130e434f0

Git commit e67fa5a2797064213c6f4c39844135cb4e6f969d by GitHub (on behalf of Donát Nagy) on 17/08/2026 at 11:00..
[analyzer] Remove irrelevant transitions in processCFGBlockEntrance (#216008)

My recent commit c76a617524fa62f85c1ff825b5d47885599c6482 cleaned up the
logic of `ExprEngine::processCFGBlockEntrance`, highlighting the fact
that it sometimes creates an extra transition that has no relevant
purpose. This commit removes this extra transition to simplify the code.

I'm confident that there was no logic that concretely looked for these
particular nodes; and this commit is a no-op if loop unrolling is
disabled (the default). Unless loop widening is also enabled, it can
only remove a node that is directly followed by a sink as its only
child.

However, this is not a NFC change, because changing the number of
exploded nodes can perturb the graph creation and traversal. I analyzed
a dozen open source projects with loop unrolling and widening both
enabled, and among almost 20.000 bug reports these perturbations caused
one new report and three lost reports, which is negligible (0.02%) and
acceptable.
https://invent.kde.org/qt/clang/llvm-project/-/commit/e67fa5a2797064213c6f4c39844135cb4e6f969d

Git commit 54414f0045e35e05b70e21f1ba0b22bc3b4eb273 by GitHub (on behalf of Matt Arsenault) on 17/08/2026 at 11:02..
GlobalISel: Migrate misc. CombinerHelper def checks to MIPatternMatch (#216671)

Replace getVRegDef + cast/opcode-check idioms across CombinerHelper
with mi_match, adding named instruction binders and operand-form
matchers as needed.

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

Git commit c8ed209c35359ccccb4ca9beeea79f408ecbe0f3 by GitHub (on behalf of Kirill Vedernikov) on 17/08/2026 at 11:20..
[NFC][MLIR][NVVM] Move tcgen05.mma collector_b tests to separate files (#216320)

This is the NFC change that moves MLIR tcgen05.mma ops with collector_b
feature to separate test files.
https://invent.kde.org/qt/clang/llvm-project/-/commit/c8ed209c35359ccccb4ca9beeea79f408ecbe0f3

Git commit 5f0f4f551b7913fc203e888fa9687df754e14897 by GitHub (on behalf of Krish Gupta) on 17/08/2026 at 11:21..
[mlir][bufferization] Add edge and error case tests for static memory planner (#216610)

Extends test coverage for the static memory planner by adding cases that
were missing from the existing suite.

Eight new analysis tests (19-26):
- Static and dynamic shapes coexisting in one function
- Both branches of scf.if deallocating the same alloc
- Dealloc at depth 3 (triply nested scf.if)
- Multi-hop alias chain through two consecutive scf.if results
- arith.select feeding into an scf.if result (cross-interface alias)
- One alloc freed in scf.if body, another in the entry block — same
arena
- Dealloc inside an else branch's nested scf.if
- scf.for body that only reads entry-block buffers (the canonical valid
loop case)

Three new error tests (3-5):
- Dynamic alloc with no dealloc is silently skipped, not an error
- Walk stops on the first bad alloc and points the error there precisely
- cf.cond_br to a sibling block is rejected as unstructured control flow

No pass changes. Tests only.
https://invent.kde.org/qt/clang/llvm-project/-/commit/5f0f4f551b7913fc203e888fa9687df754e14897

Git commit eb987cb198c06d61b9e2a7eea0aa0c21dca74227 by GitHub (on behalf of Lang Hames) on 17/08/2026 at 11:47..
[ORC] Add lookupAndApply, replacing buildProxies (#216658)

lookupAndApply composes a single atomic lookup from independent
operations, each contributing symbols and returning a handler to run on
the result. Two gains over buildProxies:

- One lookup binds everything, so every handler sees a consistent view
of the JITDylib. (buildProxies did a separate lookup per proxy)

- Each name sits next to the variable it binds, rather than going into a
lookup set in one place and coming back out of a SymbolMap elsewhere.

recordAddr and recordProxy cover the cases we have; recordProxy is in
its own header so holding a Proxy doesn't pull in the machinery to build
one. Prepare functions are independent, so two may request the same
symbol: the composed set goes through SymbolLookupSet::mergeEntries.

Proxy::Create, ProxyInit and proxyInit are removed. ProxySpecs stay
public, so operations can still be resolved under non-default names. The
asynchronous form has no in-tree callers yet.
https://invent.kde.org/qt/clang/llvm-project/-/commit/eb987cb198c06d61b9e2a7eea0aa0c21dca74227

Git commit b4a1446a4a1cb16dbf79dec4e94743ec7354631e by GitHub (on behalf of Simon Pilgrim) on 17/08/2026 at 11:48..
[X86] combine-udiv.ll - regenerate (V)PADD asm comments (#216695)
https://invent.kde.org/qt/clang/llvm-project/-/commit/b4a1446a4a1cb16dbf79dec4e94743ec7354631e

Git commit b93c855309b048828cebfe7f7a505cf25fd9c7cc by GitHub (on behalf of Lang Hames) on 17/08/2026 at 11:49..
[orc-rt] Rename "managed code" to "keepalive". NFC. (#216670)

Renames the Session's managed-code task group and its helpers so that
they name the mechanism -- the barrier that holds the Session open --
rather than a category of code:

  ManagedCodeTaskGroup                 -> KeepaliveTaskGroup
  Session::callManagedCode             -> Session::callWithKeepalive
  Session::managedCodeTokenSource      -> Session::keepaliveTokenSource
  waitForManagedCodeTasksThenShutdown  -> waitForKeepalivesThenShutdown
  ManagedCodeCaller                    -> KeepaliveCaller

and retitles the corresponding section of docs/Design.md from "Managed
code execution and shutdown" to "Keepalives and shutdown".

"Managed code" collides with the established .NET sense of the term,
which risks confusion. Naming the mechanism instead makes the purpose
clear at the call site: callWithKeepalive says that the Session is held
open across the call.

Where the documentation still needs a noun for the code itself it now
says "Session-managed code", which keeps the original meaning (JIT'd
code, plus library code loaded on its behalf) without the bare term's
collision.

TaskGroup itself is unchanged and remains generic: a keepalive is the
Session's use of a token, not a new kind of token.
https://invent.kde.org/qt/clang/llvm-project/-/commit/b93c855309b048828cebfe7f7a505cf25fd9c7cc

Git commit 034b7f56c96e34adc97c59b605beda4af84a5167 by GitHub (on behalf of ioana ghiban) on 17/08/2026 at 11:53..
[mlir][MemRef] Document `subview` runtime verifier (#214506)

Make the option of runtime verification of `memref.subview` explicit via
documentation.
https://invent.kde.org/qt/clang/llvm-project/-/commit/034b7f56c96e34adc97c59b605beda4af84a5167

Git commit 87d8872732bfc3dafb86de00eb67f178f3acab34 by GitHub (on behalf of ejose02) on 17/08/2026 at 12:02..
[flang][OpenMP] Do not emit barrier after SECTIONS with LASTPRIVATE and NOWAIT (#216018)

Fixes #192907

Flang inserted an explicit omp.barrier after SECTIONS when both
lastprivate and nowait were present, which serialized all threads at the
end of the construct and prevented nowait from taking effect.

Limit the barrier to lastprivate(conditional:) cases, where reduction
results must be finalized before the post-sections copy-back. Regular
lastprivate + nowait now matches wsloop lowering behavior.
https://invent.kde.org/qt/clang/llvm-project/-/commit/87d8872732bfc3dafb86de00eb67f178f3acab34

Git commit e98256cc6abdc97701a3b1fa2588e2628180ead2 by GitHub (on behalf of Gauarv Chaudhary) on 17/08/2026 at 12:06..
[clang-format] Fix short functions with nested braced-init (#213550)

Fixes #213286.

Keep short functions on one line when their return statement contains
nested braced initializers.

The closing brace now checks the kind of its matching opening brace, so
braced-init lists are allowed while structural
  braces still prevent merging.

  Tests:
  - `FormatTest.CustomShortFunctionOptions`
  - `FormatTest.AllowShortRecordOnASingleLine`
  - full `FormatTests` suite (1275 passed)

Signed-off-by: Gaurav Chaudhary <[email protected]>
https://invent.kde.org/qt/clang/llvm-project/-/commit/e98256cc6abdc97701a3b1fa2588e2628180ead2

Git commit e8802ef063617cd473cb0b47dd25b2fccfd2eea8 by GitHub (on behalf of Simon Tatham) on 17/08/2026 at 12:06..
[libc][test] Condition out tests that can't work on bare metal (#215830)

In bare-metal builds of libc, the `EXPECT_DEATH` macro may not be
defined. Also, `signal-macros.h` may not define the values needed for
the rest of `<signal.h>` to work. So tests that rely on either of those
things will fail to compile.

I've conditioned out the `EXPECT_DEATH` tests completely if
`EXPECT_DEATH` isn't defined. There's inherently no reliable way to
define it: you can't rely on finding out about segmentation faults by a
signal, because accessing memory outside valid C objects might silently
succeed (valid unused memory), or generate a CPU fault that no kernel
traps for you, or overwrite something important outside your program.

The check for signals in `FPExceptMatcher.cpp` can be more lenient, and
just condition out the signal-handling code, leaving the test of
cumulative FP exception flags in place, so that the checker simply
returns "no signal was caught" unconditionally.
https://invent.kde.org/qt/clang/llvm-project/-/commit/e8802ef063617cd473cb0b47dd25b2fccfd2eea8

Git commit 797a057bccd4f0e96f2775a55d2e6401e46e0275 by GitHub (on behalf of Yao Qi) on 17/08/2026 at 12:14..
[lldb] Serve MemoryCache::ReadRanges from the L2 cache as well as L1 (#216318)

`MemoryCache::Read` fetches a whole L2 cache line for any read that fits
in one,
so reading a few bytes caches the line around them. `ReadRanges` probed
only L1,
and re-fetched ranges that line already held. Callers hit this whenever
they
read an array's header and then batch the elements that follow it in the
same
line, as `AppleObjCRuntimeV2::SharedCacheImageHeaders` and
`ClassDescriptorV2::method_list_t` both do.  #201166 uses MemoryCache in
`Process::ReadRangesFromMemory`, but I didn't see why is L1 used only.

Add `FindL2CacheEntry`, a lookup that never reads from the inferior, and
consult
it after L1. When it serves every range in a batch, `ReadRanges` returns
without
calling `Process::DoReadMemoryRanges`, so no packet is sent. As in the
L1 lookup
a range spanning two lines is a miss, and a partially read line is used
only up
to what it holds.

Over the region
`TestObjCMethodsNSError.test_runtime_types_efficient_memreads`
brackets, `MultiMemRead` drops from 190 packets to 107 and the ranges
they carry
from 7004 to 6411, with the `m`/`x` count unchanged at 856. That test
now also
requires no read range to be contained in one an earlier packet already
read,
which counted 593 ranges before this change and none after.

`TestReadMemoryRangesUsesL2Cache` covers the lookup directly.
https://invent.kde.org/qt/clang/llvm-project/-/commit/797a057bccd4f0e96f2775a55d2e6401e46e0275

Git commit 3f93f77941edb2d068890ee09d1e74755d67f48c by GitHub (on behalf of Matt Arsenault) on 17/08/2026 at 12:15..
GlobalISel: Match loads by pointer operand in CombinerHelper (#216672)

Add a load matcher that binds the pointer operand (like IR's m_Load),
with optional outputs for the load instruction and its MachineMemOperand 
via m_MMO. Use it to replace the getVRegDef + dyn_cast idiom in the load 
combines.

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

Git commit 7baba22525cc9e0b7b6b5ec83d288045788312f9 by GitHub (on behalf of Harrison Hao) on 17/08/2026 at 12:38..
[IR] Add elementwise modifier to atomic stores (#210672)

Add an elementwise modifier to atomic stores to represent
per-element atomic semantics for fixed-vector stores.

Without the modifier, a vector atomic store remains a whole-value
atomic operation. With elementwise, the store behaves as if it were
expanded into one scalar atomic load per fixed-vector element, without
providing atomicity for the vector value as a whole.

Discussion:
https://discourse.llvm.org/t/rfc-add-elementwise-modifier-to-atomic-loads-and-stores/91100
https://invent.kde.org/qt/clang/llvm-project/-/commit/7baba22525cc9e0b7b6b5ec83d288045788312f9

Git commit 55e2755aa23cb880865f59618bec6caf97f59d7d by GitHub (on behalf of Akimasa Watanuki) on 17/08/2026 at 12:41..
[CIR][OpenCL] Attach kernel argument metadata to CIR functions (#200581)

Emit the CIR OpenCL kernel argument metadata attribute for kernel
functions. Preserve CIR language address-space kinds until lowering and
include argument names only when `-cl-kernel-arg-info` is enabled.
https://invent.kde.org/qt/clang/llvm-project/-/commit/55e2755aa23cb880865f59618bec6caf97f59d7d

Git commit c14ba73a927211a10ce66ac44df5403c53199206 by GitHub (on behalf of Nikolas Klauser) on 17/08/2026 at 12:44..
[libc++] Define behaviour for calling target() and target_type() on -fno-rtti std::functions (#209471)

The main aim of this change is to have the same vtable between
`-fno-rtti` and `-frtti`. Since it's very cheap to do, this also asserts
if the `function` object was created in `-fno-rtti` mode.

The vtable can be extended, since the members are either never accessed
in `-fno-rtti` mode, or are already expected to exist in `-frtti` mode.
This means that we either define behaviour that wasn't before, or we add
some extra bytes that are never accessed.
https://invent.kde.org/qt/clang/llvm-project/-/commit/c14ba73a927211a10ce66ac44df5403c53199206

Git commit 799f4c78ae7ab007aa8c6fb3a38bfe33a39e0229 by GitHub (on behalf of Arseniy Obolenskiy) on 17/08/2026 at 12:47..
[mlir][SPIR-V] Add ComplexToSPIRV lowering for complex.angle (#214172)

Lower complex.angle to spirv.GL.Atan2/spirv.CL.Atan2 on the real and
imaginary components, following the existing complex.abs pattern
https://invent.kde.org/qt/clang/llvm-project/-/commit/799f4c78ae7ab007aa8c6fb3a38bfe33a39e0229

Git commit 4afd874c4a51827a101bfcc0747f067f845d118b by GitHub (on behalf of Deepak Shirke) on 17/08/2026 at 13:00..
[GlobalISel] Add G_EXTRACT_SUBVECTOR to computeKnownBits (#214533)

Port the SDAG EXTRACT_SUBVECTOR computeKnownBits handling to GlobalISel.
Offsets the demanded elements by the subvector index to propagate known
bits from the source vector to the extracted subvector.

Part of #150515.
https://invent.kde.org/qt/clang/llvm-project/-/commit/4afd874c4a51827a101bfcc0747f067f845d118b

Git commit 9724b4f156d13b1ae66a04ddd26f070a398c3cc3 by GitHub (on behalf of Dmitry Sidorov) on 17/08/2026 at 13:01..
[SLP] Check the fmul's own flags in canConvertToFMA (#216599)

CheckForContractable ran the operand bundle through the fadd's
InstructionsState, so every fmul in it failed the main/alt op test and
was skipped. The flags stayed set and allowContract was trivially true,
which priced a plain fmul feeding a contract fadd as if it would fuse.
The backend will not do that. Give the lambda the state to assess
against and pass the fmul's own.

Assisted-by: Claude Code Opus 5
https://invent.kde.org/qt/clang/llvm-project/-/commit/9724b4f156d13b1ae66a04ddd26f070a398c3cc3

Git commit d41f8330d61b7fb1467051a735fe8b26d869ac9c by GitHub (on behalf of Shaurya Srivastava) on 17/08/2026 at 13:05..
[X86] Fold scalar ABS_MIN_POISON store of a load to PABS (#216697)

Extend the scalar load→abs→store SIMD fold from #210654 to `ISD::ABS_MIN_POISON` (`llvm.abs(..., i1 true)`).

That form was left on `neg`+`cmov` while `llvm.abs(..., i1 false)` already
used `PABS`. Vector `PABS` is `ISD::ABS`; `PABS(INT_MIN)` is `INT_MIN`,
which is a valid refinement of poison.
https://invent.kde.org/qt/clang/llvm-project/-/commit/d41f8330d61b7fb1467051a735fe8b26d869ac9c

Git commit 89ad6f51f475cd6fe190cdeb51fc20f86c151fbc by GitHub (on behalf of David Spickett) on 17/08/2026 at 13:13..
[lldb][test] Fix skip in TestWriteMemoryWithHWBreakpoint.py (#216723)

In a87b27fd5161ec43527fc3356852046a321ea82c, the opposite
skip was put in. It should skip if hardware breakpoints are 
*not* supported.

Also that commit added a stray "skip". I have removed that and
fixed the incorrect variable name.
https://invent.kde.org/qt/clang/llvm-project/-/commit/89ad6f51f475cd6fe190cdeb51fc20f86c151fbc

Git commit d2bd0203bee02681b0a150fb8d2d6563b7e56b2e by GitHub (on behalf of Tom Eccles) on 17/08/2026 at 13:24..
Revert "workflows/release-binaries: Disable flang on Darwin (#164667)" (#216667)

This reverts commit 6d54a5e5b83ce3502b7a3488fea5afe1c8bf9c5c.

Flang Darwin builds were reverted due to #160546. That issue has not
been reproducible (at least on my machine) for several months. There was
a request for MacOS builds on the most recent flang community call.

Flang is not enabled in the MacOS pre-commit CI.

Closes #160546
https://invent.kde.org/qt/clang/llvm-project/-/commit/d2bd0203bee02681b0a150fb8d2d6563b7e56b2e

Git commit ca599aa1af4deddb5c37cb9c00b975a7d8ebfbde by GitHub (on behalf of Mugundan S) on 17/08/2026 at 13:26..
[AArch64] Fold vector select with power-of-2 bit-test to CMTST+BSP (#209100)

Fixes: #107088

* A vector select whose condition is (X & Mask) == Mask, where Mask is a
power-of-2 constant splat, was generating suboptimal code: AND + CMEQ +
BIF instead of CMTST + BIF.
 
* This happens because the condition is canonicalized to (X & Mask) ==
0, and AArch64 was not folding the resulting SETCC(AND(X, Mask), 0,
SETEQ) into a CMTST based mask.
 
* This patch adds a SelectionDAG fold in AArch64ISelLowering.cpp to
lower vector SETCC(AND(X, Mask), 0, SETEQ) to an inverted
AArch64ISD::CMTST. The existing bitselect lowering can then absorb the
inversion and emit CMTST.
 
Note: Test cases were derived from those reported by the original
author.
https://invent.kde.org/qt/clang/llvm-project/-/commit/ca599aa1af4deddb5c37cb9c00b975a7d8ebfbde

Git commit acf9ee4f52a38979f5edbfedd2d82487403be5cb by GitHub (on behalf of Ingo Müller) on 17/08/2026 at 13:39..
[bazel:mlir] Fix build after c8a0460. (#216719)

Signed-off-by: Ingo Müller <[email protected]>
https://invent.kde.org/qt/clang/llvm-project/-/commit/acf9ee4f52a38979f5edbfedd2d82487403be5cb

Git commit 4f1066bd8249d0a02611778530774aacd63d5092 by GitHub (on behalf of Alexey Bataev) on 17/08/2026 at 13:56..
[SLP]Recalculate cleared deps for all cancelled copyable elements

Deps of a cancelled copyable element were recalculated only for
control-dependency nodes; a speculatable one stayed unschedulable and
deadlocked the final scheduling. Recalculate unconditionally.

Fixes #216544

Reviewers: 

Pull Request: https://github.com/llvm/llvm-project/pull/216734
https://invent.kde.org/qt/clang/llvm-project/-/commit/4f1066bd8249d0a02611778530774aacd63d5092

Git commit 9da823c884ec9f03be3983cc68b2252b2d213207 by GitHub (on behalf of Nick Sarnie) on 17/08/2026 at 14:21..
[libsycl][unit][CMake] Fix unittests gtest CMake target (#216344)

This was exposed by my recent change moving the `gtest` unit tests to be
called by `lit` (but still using `gtest`) but it seems the problem was
technically there before.

We need to use a special gtest target for the runtime build. Luckily
LLVM infra provides a cmake target we can depend on that will just make
it work. More info
[here](https://github.com/llvm/llvm-project/blob/ec26997e2e4606d97918a4a082c4f93ca38a6f46/third-party/unittest/CMakeLists.txt#L25)
if interested.

Other runtimes do the same thing, see
[here](https://github.com/llvm/llvm-project/blob/828d2d7fb65a9cd5946b347ad5173e3bdb21387d/openmp/tools/omptest/CMakeLists.txt#L88)
for example.

Co-authored-by: Claude Opus 4.8 (1M context) <[email protected]>
https://invent.kde.org/qt/clang/llvm-project/-/commit/9da823c884ec9f03be3983cc68b2252b2d213207

Git commit 2618135dad905be68a3317af046fc1d53bc292db by GitHub (on behalf of Yaxun (Sam) Liu) on 17/08/2026 at 15:24..
[HIP] Link profile runtime in device-only lld path (#211675)

HIP device-only code object links can use the direct lld path in
HIPAMD.cpp. That path did not add the profile runtime, so device-only
builds with profile generation missed `libclang_rt.profile.a`.

This patch adds the normal profile runtime handling to that linker path
and covers it with a driver test.
https://invent.kde.org/qt/clang/llvm-project/-/commit/2618135dad905be68a3317af046fc1d53bc292db

Git commit d9274cddde31007dab8db336db6fdaf44b5e3379 by GitHub (on behalf of Kristina Bessonova) on 17/08/2026 at 15:42..
[AArch64][GlobalISel] Preserve scalar type when widening atomic G_STORE (#216162)

Use `changeElementSizeTo` instead of `changeTo` in the G_STORE
legalization rule for narrow atomic stores.

`changeTo` changes the type of the stored value to generic `s32`, which
can be propagated to its defining instruction. For example, this can
turn an integer `G_AND` into an `s32` operation and prevent it from
being correctly selected.

Changing only the element size preserves the value's scalar type while
still widening the value as required by the legalization rule.
https://invent.kde.org/qt/clang/llvm-project/-/commit/d9274cddde31007dab8db336db6fdaf44b5e3379

Git commit 759e2140f2f8daca5b7927789df45e2d003d805c by GitHub (on behalf of Alex MacLean) on 17/08/2026 at 16:18..
[NVPTX] Cleanup overloaded intrinsic addrspace matching (NFC) (#213110)
https://invent.kde.org/qt/clang/llvm-project/-/commit/759e2140f2f8daca5b7927789df45e2d003d805c

Git commit 5f81b8d924fba12b4e851352959b5c4a54260d9a by GitHub (on behalf of Adam Smith) on 17/08/2026 at 16:24..
[CIR] Derive record padding from the member marks (#215176)r

Now that every record member carries a kind, the record-level `padded`
bool is redundant: a record is padded exactly when some member is marked
pad. Drop the parameter and answer `getPadded()` from the marks.

That also fixes `computeStructDataSize`, which had read the bool as "the
last member is tail padding" and so dropped a real member when padding
sat between two data members. It now drops the trailing run, so an
all-pad record sizes to zero.

Assisted-by: Cursor / claude-opus-5
https://invent.kde.org/qt/clang/llvm-project/-/commit/5f81b8d924fba12b4e851352959b5c4a54260d9a

Git commit 782f1130177b2c792dc37f0923d21d187a4c150b by GitHub (on behalf of Rainer Orth) on 17/08/2026 at 16:30..
[sanitizer] Skip hanging tests on NetBSD (#216712)

Several sanitizer tests hang indefinitely on NetBSD:

```
MemorySanitizer-Unit :: ./Msan-x86_64-Test
MemorySanitizer-Unit :: ./Msan-x86_64-with-call-Test
MemorySanitizer-X86_64 :: zero_alloc.cpp
ThreadSanitizer-x86_64 :: signal_cond.cpp
libFuzzer-x86_64-default-NetBSD :: reload.test
```

All of them loop and don't time out, so they need to be terminated
manually for `ninja check-all` to complete. To avoid this, this patch
skips the affected tests or subtests. Unfortunately, the Msan unit tests
still hang on exit in `__cxa_finalize` even if all subtests are skipped
with `llvm-lit -gtest_filter=-*`.

Tested on `x86_64-pc-netbsd11.0`, `x86_64-pc-freebsd15.1`, and
`x86_64-pc-linux-gnu`.
https://invent.kde.org/qt/clang/llvm-project/-/commit/782f1130177b2c792dc37f0923d21d187a4c150b

Git commit 0b02ca0e2295b6b54f9f5a09f02cc5ee5c2e8ae1 by GitHub (on behalf of Kazu Hirata) on 17/08/2026 at 16:30..
[mlir] Remove dead declarations (#216651)

The corresponding function definitions were removed on March 29, 2019
in 4dc7af9da8837a5f9515c4622e093578fb6ab766
https://invent.kde.org/qt/clang/llvm-project/-/commit/0b02ca0e2295b6b54f9f5a09f02cc5ee5c2e8ae1

Git commit 7c26749bab308ca21a8145dcaa403f59b32ac29f by GitHub (on behalf of Matt Arsenault) on 17/08/2026 at 16:31..
NVPTX: Fix using getVRegDef on a physical register (#216735)
https://invent.kde.org/qt/clang/llvm-project/-/commit/7c26749bab308ca21a8145dcaa403f59b32ac29f

Git commit 052e6ffdbf68cab9f14ed6369b916127f89d0ae1 by GitHub (on behalf of Maddy Dunn) on 17/08/2026 at 16:36..
[mlir][tosa] Add input_unsigned attribute to CAST (#215838)

- Add optional attribute input_unsigned
- Add attributeCheckCast
- Update verification for CAST to reflect new attribute rules

Signed-off-by: Madeleine Dunn <[email protected]>
https://invent.kde.org/qt/clang/llvm-project/-/commit/052e6ffdbf68cab9f14ed6369b916127f89d0ae1

Git commit 94a5aa6f1377c6dead25b4d68ac82b43e11a010e by GitHub (on behalf of jimingham) on 17/08/2026 at 16:45..
Add a ValueCheck construction method that takes an SBValue (#216208)

Making ValueCheck's can be pretty tedious. But in cases where you are
checking an SBValue that comes from some complex operation, e.g. an
expression evaluation, you can arrange to have the result you expect as
another value in your test program. In that case, it would be much
easier to make a SBValue from the reference object, and then compare the
result against that reference ValueCheck.

This PR adds the valobj based ValueCheck and uses it to replace the
hand-crafted one in TestCPPExprResult.py.

---------

Co-authored-by: Med Ismail Bennani <[email protected]>
https://invent.kde.org/qt/clang/llvm-project/-/commit/94a5aa6f1377c6dead25b4d68ac82b43e11a010e

Git commit 9a5bd30f350ce21213bd895f33612ea5a9c3f9d7 by GitHub (on behalf of Matt Arsenault) on 17/08/2026 at 16:57..
clang/AMDGPU: Use feature bitset instead of ArchAttr (#216674)

Convert from the legacy getArchAttrAMDGCN manual bitmask checks to using
the new generated bitset. These are the easy cases. sramecc and xnack
require more supporting work so will be done later.

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

Git commit 0b99968b1a12eb987314eacb5cd6d28e7e64116e by GitHub (on behalf of Hendrik Hübner) on 17/08/2026 at 17:02..
[InstCombine] Fix crash on dereferencing null insertion point (#216363)

Fix, add assertions and regressin test.

The issue occurred when trying to invert a phi inside a catchswitch
block, because there is no legal insertion point after the phi.
https://invent.kde.org/qt/clang/llvm-project/-/commit/0b99968b1a12eb987314eacb5cd6d28e7e64116e

Git commit 3eeaa773c33676a0942c8bffb2130bae8bbe926a by GitHub (on behalf of Matt Arsenault) on 17/08/2026 at 17:04..
AMDGPU: Fix machine sink crash on an undef SGPR operand (#216721)

isSafeToSink dereferenced the defining instruction of an
SGPR use without checking for a null def, which crashes on
an undef operand that has no defining instruction.

Found by AI while working on something else.

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

Git commit 60fd524f6fdc03208420a6125373a1d853ddc47f by GitHub (on behalf of Craig Topper) on 17/08/2026 at 17:05..
[AMDGPU] Use false instead of converting MCRegister() to bool. NFC (#216635)
https://invent.kde.org/qt/clang/llvm-project/-/commit/60fd524f6fdc03208420a6125373a1d853ddc47f

Git commit cf7e84e3f48a58f97af0abce7fd24fdb4b1f5797 by GitHub (on behalf of Joshua Batista) on 17/08/2026 at 17:12..
Test locally scoped resources (#190037)

This PR adds tests to clang to document local resource behavior.
Tests that emit any diagnostics in Sema go to Semahlsl. Test
organization is described here: https://github.com/llvm/wg-hlsl/pull/414

Fixes: https://github.com/llvm/llvm-project/issues/214537
Context: https://github.com/llvm/wg-hlsl/pull/414

Assisted by: Github Copilot
https://invent.kde.org/qt/clang/llvm-project/-/commit/cf7e84e3f48a58f97af0abce7fd24fdb4b1f5797

Git commit 90138fe4cc5bd9250b3dba83d0f82bf679d06693 by GitHub (on behalf of Ebuka Ezike) on 17/08/2026 at 17:19..
[lldb-dap] Only mark disconnecting when we are actually disconnecting (#216356)

Threads
 ```
 TransportHandler      |  Request Handler     | State
 =====================================================
 new request           | free                 | disconnecting = false |
                       |                      | queue = 1             |
 disconnect request    | handled new request  | disconnecting = true  |
                       |                      | queue = 0
```
In the transport handler we have set m_disconnecting to true. In the window before we push the disconnect request into the queue, the request handler thread finished handling the previous request and is in the while loop. It waits on the m_queue_cv and sees. m_disconnecting = true and queue is empty.

DAP shuts down because it assumes there is nothing else to do. The client then times out waiting for the disconnect response.

Detach the thread if we cannot join it and let the OS deal with the thread cleanup.
https://invent.kde.org/qt/clang/llvm-project/-/commit/90138fe4cc5bd9250b3dba83d0f82bf679d06693

Git commit 8b990b77ed705362e99e76cdfe9772965ea4ae56 by GitHub (on behalf of guyfischman) on 17/08/2026 at 17:32..
[AArch64] Select sqdmulh for smul.fix.sat with scale == eltbits-1 (#211579)

Follow-up to #209351 (which vectorized the generic expansion): on
AArch64, smul.fix.sat with scale == eltbits-1 is exactly sqdmulh, so
select it directly instead of the generic clamp.
https://invent.kde.org/qt/clang/llvm-project/-/commit/8b990b77ed705362e99e76cdfe9772965ea4ae56

Git commit 9bfcc0509e541b345210f6e159dc9fe0af86a890 by GitHub (on behalf of Kyungtak Woo) on 17/08/2026 at 17:38..
[bazel] Include Orc/Shared/SPSCI headers in OrcShared target (#216634)

This fixes two active bazel failures:
1. Update `OrcShared` in `llvm/BUILD.bazel` to recursively glob headers
under
`include/llvm/ExecutionEngine/Orc/Shared/**/*.h`.
2. libc float128 failures


Gemini assisted
https://invent.kde.org/qt/clang/llvm-project/-/commit/9bfcc0509e541b345210f6e159dc9fe0af86a890

Git commit e7b3f73552ea839702edce448dd046d3b974a9ef by GitHub (on behalf of Alex MacLean) on 17/08/2026 at 17:43..
[ExpandVariadics] Move NewPM class to RequiredPassInfoMixin (#216597)

This pass is required lowering for most targets that use it during
CodeGen.
https://invent.kde.org/qt/clang/llvm-project/-/commit/e7b3f73552ea839702edce448dd046d3b974a9ef

Git commit 5ccbdeff313a0b0bdf613848109466e0928d5603 by GitHub (on behalf of Craig Topper) on 17/08/2026 at 17:44..
[RISCV] Add HasConditionalMoveFusion Zibi patterns. (#216452)

Assisted-by: Claude
https://invent.kde.org/qt/clang/llvm-project/-/commit/5ccbdeff313a0b0bdf613848109466e0928d5603

Git commit f6d259f721dc4b59fe5eb7f9139d5972f1008d3b by GitHub (on behalf of Alexey Bataev) on 17/08/2026 at 17:47..
[SLP][NFC]Add a test with the missed vectorization opportunity, NFC



Reviewers: 

Pull Request: https://github.com/llvm/llvm-project/pull/216790
https://invent.kde.org/qt/clang/llvm-project/-/commit/f6d259f721dc4b59fe5eb7f9139d5972f1008d3b

Git commit ca7ffcae3998320c44c2ab774949701f5371da6d by GitHub (on behalf of Aviral Goel) on 17/08/2026 at 17:50..
[clang][ssaf] Link static libraries and multi-arch static libraries (#215349)

This change introduces support for linking static libraries and
multi-arch static libraries. To implement this, we have added two `link`
overloads to the `EntityLinker`: a static library folds in as a bundle
of TU summaries, and a multi-arch static library contributes only the
static library with the matching target triple. The target triple is
supplied through a new optional flag, `--target-triple`. If unspecified,
it is inferred from the first input, if possible.

rdar://184656074
https://invent.kde.org/qt/clang/llvm-project/-/commit/ca7ffcae3998320c44c2ab774949701f5371da6d

Git commit ec85dd474365e2e195617ee705924784a14cf0ce by GitHub (on behalf of Matt Arsenault) on 17/08/2026 at 17:51..
AMDGPU: Fix using getVRegDef on a physical register in SIFoldOperands (#216775)

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

Git commit b53468e16f501c672c70e07580476d3709ac9bca by GitHub (on behalf of Matt Arsenault) on 17/08/2026 at 17:56..
AMDGPU: Use mi_match for more manual selector patterns (#216726)

Use mi_match G_SHUFFLE_VECTOR/G_FRAME_INDEX/G_SUB checks. Add new
matchers to check the shufflevector and frame index cases, avoiding
raw getVRegDef uses.

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

Git commit b4cf46103cdbbecb16339bb8e96dcbeb99330c06 by GitHub (on behalf of Sophia Herrmann) on 17/08/2026 at 17:57..
[LLVMOffload] Fix unitialized variable in test from #212373 (#216788)

This test was flaky due to using an uninitialized variable, leading to
buildbot failures. This PR initializes it to zero and renames the kernel
to `incrementCounter` to match.
https://invent.kde.org/qt/clang/llvm-project/-/commit/b4cf46103cdbbecb16339bb8e96dcbeb99330c06

Git commit 27ffa745f3a7eaafe5f3491ace03d345e3a80129 by GitHub (on behalf of jimingham) on 17/08/2026 at 18:11..
Don't ask trampoline handler plans to step past line 0. (#216770)

That isbetter done by the source line stepping plans.
This fixes a test suite failure on the swift fork, but I don't know how
to really write a test for it since it depends on getting to a function
whose first instruction is attributed to line 0 by an ObjC direct
dispatch. Turns out swift does this in its present incarnation.

But this division of labor really is the right way to work the machine,
since that makes the trampoline plans easier to reason about, and if
stepping past line 0 is desired, there's always going to be a source
line stepping plan controlling the step that will do the job.
https://invent.kde.org/qt/clang/llvm-project/-/commit/27ffa745f3a7eaafe5f3491ace03d345e3a80129

Git commit e68a5749832f133742187cf6f4898dc3fd927a34 by GitHub (on behalf of Keshav Vinayak Jha) on 17/08/2026 at 18:16..
[AMDGPU][GIsel][NPM] Port AMDGPUGlobalISelDivergenceLowering to NPM (#216657)

Porting `AMDGPUGlobalISelDivergenceLowering` to work with the New
PassManager to support GISel.

Assisted-by: Codex
---------

Signed-off-by: Keshav Vinayak Jha <[email protected]>
https://invent.kde.org/qt/clang/llvm-project/-/commit/e68a5749832f133742187cf6f4898dc3fd927a34

Git commit d5b28a3ba0d1db39b5959e0293ca192ab2119833 by GitHub (on behalf of Ellis Hoag) on 17/08/2026 at 18:18..
[NFC][InstrProf] Remove unused test profiles (#216782)

`basic.profraw` was added in
https://github.com/llvm/llvm-project/commit/f95b2f1acf1171abb0d00089fd4c9238753847e3
but it seems to be unused.

The usuage of `split-layout.profdata` was removed in
https://github.com/llvm/llvm-project/pull/109679 but the file itself was
not removed.
https://invent.kde.org/qt/clang/llvm-project/-/commit/d5b28a3ba0d1db39b5959e0293ca192ab2119833

Git commit f646f7395fe1fbb05d78a42871cb72bc31e4d7f9 by GitHub (on behalf of Hsiangkai Wang) on 17/08/2026 at 18:20..
[mlir][spirv] Add InBoundsAccessChain op (#216682)

Add the SPIR-V opcode, ODS definition, verifier hook, and
canonicalization support for spirv.InBoundsAccessChain.
https://invent.kde.org/qt/clang/llvm-project/-/commit/f646f7395fe1fbb05d78a42871cb72bc31e4d7f9

Git commit fbfff87687892a1c9e183b466f88f0a3e7106708 by GitHub (on behalf of Alexey Samsonov) on 17/08/2026 at 18:22..
[libc] Add a couple of constants to elf.h. (#216784)

* STT_GNU_IFUNC is a GNU-specific ELF symbol type used to implement
ifunc's, which is often used in parser code.
* Add EM_PPC64 denoting 64-bit PowerPC architecture (in addition to
i386/x86, ARM, and RISC types we already support).
https://invent.kde.org/qt/clang/llvm-project/-/commit/fbfff87687892a1c9e183b466f88f0a3e7106708

Git commit 6df83602178bcdd9cedeb1e5740701b17e9215db by GitHub (on behalf of Alex MacLean) on 17/08/2026 at 18:34..
[NVPTX] Move a few NewPM pass classes to Required (#216595)
https://invent.kde.org/qt/clang/llvm-project/-/commit/6df83602178bcdd9cedeb1e5740701b17e9215db

Git commit ec68d09b410b7912b585027453bf1331f6329d26 by GitHub (on behalf of Eric Christopher) on 17/08/2026 at 18:35..
[DSE] Stop double-counting the dead slice offset in shortenAssignment (#216227)

  DSE marked the wrong part of a variable dead when a shortened store started
  at an offset from its base object, leaving stale values visible in the
  debugger for bytes the shortened store no longer covered.

  shortenAssignment passed calculateFragmentIntersect both the materialized
  destination and DeadStart * 8. DeadStart is that destination's offset from the
  base object, and calculateFragmentIntersect already measures the destination
  against the dbg.assign address, so this counted the same distance twice.

  SROA and AssignmentTrackingAnalysis pass a base pointer and a separate offset
  into it. DSE already passes the materialized destination, so its slice offset
  is zero when DSE removes the beginning of the store and the size of the
  surviving store when it removes the end. Remove OldOffsetInBits from
  shortenAssignment.

  Add coverage for the three affected cases. shortenBeginWholeFragment checks
  that DSE unlinks the whole 12-byte assignment when it removes every byte the
  record describes. shortenEndPartial checks that removing the final four bytes
  produces a four-byte dead fragment starting at byte 12. shortenBeginPartial
  checks that the 60 removed bytes start at byte 8 rather than applying that
  eight-byte offset twice.

  No regressions on check-llvm or check-lldb; unfortunately none of the nine
  -ggdb/-O2 tests exercise this, so I read the values back in lldb directly.

  Assisted by AI.
https://invent.kde.org/qt/clang/llvm-project/-/commit/ec68d09b410b7912b585027453bf1331f6329d26

Git commit 0132a93ff5da2a60ca165c2e991a00176bc425ae by GitHub (on behalf of Ellis Hoag) on 17/08/2026 at 18:41..
[NFC][MemProf] Remove unused memprofraw test file (#216778)

`llvm/test/Transforms/PGOProfile/Inputs/memprof_loop_unroll.memprofraw`
was created in https://github.com/llvm/llvm-project/pull/79433 for the
`llvm/test/Transforms/PGOProfile/memprof_loop_unroll.ll` test, but the
usage was removed in https://github.com/llvm/llvm-project/pull/165338 in
favor of an inline `.yaml` file. Remove the `.memprofraw` file and the
generator script.
https://invent.kde.org/qt/clang/llvm-project/-/commit/0132a93ff5da2a60ca165c2e991a00176bc425ae

Git commit b71ce8f90bdcdda898d2dce62350c212461d17c7 by GitHub (on behalf of Alex MacLean) on 17/08/2026 at 18:44..
[llvm] Remove GlobalVariable::getAlignment (NFC) (#213300)
https://invent.kde.org/qt/clang/llvm-project/-/commit/b71ce8f90bdcdda898d2dce62350c212461d17c7

Git commit 12da120df184ab620c70deb9c4d7be29990a4fdf by GitHub (on behalf of Ron Green [NVIDIA]) on 17/08/2026 at 18:48..
[flang][OpenACC] Fix crash on ATTACH/DETACH with an unresolved name (#216801)

`AccAttributeVisitor::EnsureAllocatableOrPointer()` passes the last name of the
designator to `IsAllocatableOrObjectPointer()`, which accepts a null `Symbol`
pointer and returns `false` for it. When the argument of an `ATTACH` or `DETACH`
clause fails name resolution -- for example a component reference whose derived
type could not be resolved -- that name's symbol is null, so control reaches the
error-reporting path, which then dereferences the same null symbol and crashes
the compiler.

Because the crash happens during name resolution, it precedes the point where
semantic diagnostics are emitted, so the compiler dies with no output at all
rather than reporting the errors that caused the name to be unresolved.

Reproducer:

```fortran
subroutine test_attach_unresolved
  type :: ty
    integer :: i
  end type ty
  type(ty) :: x
  !$acc enter data attach(x%bad)
end subroutine test_attach_unresolved
```

`flang -fsyntax-only -fopenacc` on the above segfaults. With this change it
reports the expected `Component 'bad' not found in derived type 'ty'`.

Fix: skip the check when the name is unresolved. Name resolution has already
reported an error for it, so there is nothing left to diagnose.

A regression test is added covering both `ATTACH` and `DETACH`.
https://invent.kde.org/qt/clang/llvm-project/-/commit/12da120df184ab620c70deb9c4d7be29990a4fdf

Git commit 992a29122aa487236e0d2cce02e149a6acc54cc1 by GitHub (on behalf of Pranav Kant) on 17/08/2026 at 18:50..
[bazel] Fixes #215349 (#216811)
https://invent.kde.org/qt/clang/llvm-project/-/commit/992a29122aa487236e0d2cce02e149a6acc54cc1

Git commit a7ef89ad9796e6de3a085ec75a13f0dfec5a8059 by GitHub (on behalf of Alex Langford) on 17/08/2026 at 18:50..
Revert "[lldb][test] Fix skip in TestWriteMemoryWithHWBreakpoint.py" (#216806)

Reverts llvm/llvm-project#216723
https://invent.kde.org/qt/clang/llvm-project/-/commit/a7ef89ad9796e6de3a085ec75a13f0dfec5a8059

Git commit aa2c1b50cb850ad46afb1cff3e430b129ee51260 by GitHub (on behalf of dlei6g) on 17/08/2026 at 18:58..
[CodeGen] Fix stale LiveIntervals regmask tables after MachineBasicBl… (#209610)

MachineBasicBlock::splitAt() moves the tail of a block -- including any
call instructions carrying register-mask operands -- into a newly
created block. When LiveIntervals is attached it calls
LIS->insertMBBInMaps() for the new block, which records the block with
zero regmask slots. That is only correct for a fresh, empty block:
because the tail (and its regmasks) was *moved* out of the original
block, the per-block RegMaskBlocks index for both blocks is left stale,
so checkRegMaskInterference() can miss a call clobber and the register
allocator can assign a live value to a clobbered physical register.

Add a LiveIntervals::splitAt(Orig, SplitBB) entry point that inserts
SplitBB into the SlotIndexes/regmask maps and then re-slices the moved
regmask slots out of Orig's RegMaskBlocks entry into SplitBB's
(RegMaskSlots is sorted, so the slots that moved are those at/after
SplitBB's start index). MachineBasicBlock::splitAt() now calls it in
place of insertMBBInMaps().

The re-slicing helper (reassignRegMaskSlots) and the shared
map-insertion helper are private; insertMBBInMaps() is documented as
expecting an empty block and, under EXPENSIVE_CHECKS, asserts the block
has no regmask operands so that misuse is caught.

Adds a LiveIntervals unit test (SplitAtMovesRegMaskInterference) that
splits a block so a value becomes block-local yet still crosses a call
regmask, and checks that checkRegMaskInterference() still reports the
clobber.

**AI assistance disclosure** (per the LLVM AI Tool Use Policy): the MIR
test and parts of this commit message were drafted with an AI tool
(Claude, Anthropic). I have reviewed and verified all code and tests and
take full responsibility for this contribution.
https://invent.kde.org/qt/clang/llvm-project/-/commit/aa2c1b50cb850ad46afb1cff3e430b129ee51260

Git commit d7594bf4caa568e843e961205631adba44b8ab87 by GitHub (on behalf of Alexis Engelke) on 17/08/2026 at 19:01..
[Clang][CodeGen] Use ptrtoaddr for pointer diff (#210729)

We don't have to expose the provenance of pointers for pointer
subtraction, so use ptrtoaddr instead of ptrtoint if -fwrapv-pointer is
not set.
https://invent.kde.org/qt/clang/llvm-project/-/commit/d7594bf4caa568e843e961205631adba44b8ab87

Git commit a10f62e878750ca72c61c26bc443cf087a8ee411 by GitHub (on behalf of Erich Keane) on 17/08/2026 at 19:03..
[CIR] Implement aligned-array-delete. (#216789)

This ends up being a pretty trivial implementation, since we just have
to add the additional i64 argument to the call. This patch adds that,
after threading the alignment through CIR.

Also, the type-aware and destroying deletes aren't valid on a array
delete, so replace those checks with 'assert' instead.
https://invent.kde.org/qt/clang/llvm-project/-/commit/a10f62e878750ca72c61c26bc443cf087a8ee411

Git commit 1b17c3323ac4037d2f591783c98d26ad64f9c177 by GitHub (on behalf of Manuel Carrasco) on 17/08/2026 at 19:08..
Add support for NSDI DebugLine and DebugNoLine. (#215851)

Add support for
[DebugLine](https://github.khronos.org/SPIRV-Registry/nonsemantic/NonSemantic.Shader.DebugInfo.html#DebugLine)
and DebugNoLine.
https://invent.kde.org/qt/clang/llvm-project/-/commit/1b17c3323ac4037d2f591783c98d26ad64f9c177

Git commit e38d4c3bb4c9c704142f2cd0a70a78447e9116c4 by GitHub (on behalf of Matt Arsenault) on 17/08/2026 at 19:18..
RISCV: Fix VL optimizer crash on an undef VL operand (#216803)

Found by AI while working on something else.

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

Git commit b3bac42e660e2337e2b6443bd7b08667147fc764 by GitHub (on behalf of kwyatt-ext) on 17/08/2026 at 19:19..
[flang] Improve error for misplaced statement after CONTAINS in derived type (#215886)

A statement after `CONTAINS` in a derived type that is not a type-bound
procedure binding (e.g. a second `CONTAINS`, an `IMPORT`, or a misplaced
subprogram) leaked the intrinsic type-spec parse failures (`expected
'COMPLEX'`, `expected 'INTEGER'`, ...) instead of reporting that a
type-bound procedure binding was expected. In the misplaced-subprogram
case flang emitted an avalanche of unrelated `expected '<type-keyword>'`
errors.

This is a diagnostic regression from #203379, which added
`DataComponentDefStmt` as a trailing alternative in the
type-bound-proc-binding parser. Its intended `fail<>()` message only
fires when `DataComponentDefStmt` fully matches; for other invalid
statement the partial parse into `declarationTypeSpec` displaced the
recovery message in `CombineFailedParses`.

This patch wraps the binding alternatives in `withMessage()` so that
when none of them match a token a single clear message is emitted:

```
error: expected a type-bound procedure binding (PROCEDURE, GENERIC, or FINAL) after CONTAINS
```

The specific `component definition must precede CONTAINS in a derived
type` message is still produced for a genuine misplaced component
definition (`withMessage` only overrides when no tokens were matched),
and malformed `PROCEDURE`/`GENERIC`/`FINAL`/component statements keep
their own specific diagnostics.

`flang/test/Parser/recovery09.f90` is extended to cover the
double-`CONTAINS`, `IMPORT`, and misplaced-subprogram cases.

This implements the fix for
https://github.com/llvm/llvm-project/issues/215849

Assisted-by: AI
https://invent.kde.org/qt/clang/llvm-project/-/commit/b3bac42e660e2337e2b6443bd7b08667147fc764

Git commit a6c300e097a3f69833129c5afe234977faeb1207 by GitHub (on behalf of Matt Arsenault) on 17/08/2026 at 19:28..
AMDGPU: Use mi_match for selector vector-source instruction lookups (#216792)

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

Git commit b489177a0142be84bbf75c40302e2f3049d223c2 by GitHub (on behalf of Craig Topper) on 17/08/2026 at 19:41..
[AMDGPU] Don't use MCRegister to hold Dwarf register numbers. NFC (#216766)
https://invent.kde.org/qt/clang/llvm-project/-/commit/b489177a0142be84bbf75c40302e2f3049d223c2

Git commit 55194486eda68bf6090d757ad57109f4b8e880ee by GitHub (on behalf of Oleksandr Tarasiuk) on 17/08/2026 at 19:48..
[Clang] Prevent an assertion failure when instantiating an invalid friend function template (#216727)к

Fixes #216694

---

This patch addresses an assertion failure that occurs when instantiating
an invalid friend function template by marking its `FriendDecl` wrapper
as invalid.
https://invent.kde.org/qt/clang/llvm-project/-/commit/55194486eda68bf6090d757ad57109f4b8e880ee

Git commit 298ee5b10407d114189e623636d613ad5e13f56e by GitHub (on behalf of Dhruva Chakrabarti) on 17/08/2026 at 19:50..
[1/2][AMDGPU] Fixed crash due to virtual register defs not dominating uses (#198472)

Fixes https://github.com/llvm/llvm-project/issues/196671.

Fixes duplicate ROCM-24494, LCOMPILER-2224.

In Rewrite AGPR-Copy-MFMA pass, a spill reload may not have a dominating
spill store. If such a slot is unspilled into a vreg, the elimination
phase crashes because virtual register defs do not dominate all uses.
This patch checks for that dominance property for all reloads and skips
unspilling if such a condition is found.

This patch is adapted from 
https://github.com/llvm/llvm-project/pull/167347

Cherry-picked https://github.com/ROCm/llvm-project/commit/e5d02ddb
Authored by: Austin Kerbow <[email protected]>

Instead of scanning through instructions within the reload basic block,
LiveStacks are used to find a store within that basic block.

2 tests are added, the LL test is adapted from 
https://github.com/llvm/llvm-project/issues/196671 and the MIR test is
generated from the LL file. The CHECK lines verify that lack of
joint-dominance property is found.

PR https://github.com/llvm/llvm-project/pull/200126 builds on this patch
by trying to insert an IMPLICIT_DEF so that
the unspill can proceed.

Co-authored by: Austin Kerbow <[email protected]>

Assisted-by: Cursor/Claude Opus

---------

Co-authored-by: theRonShark <[email protected]>
https://invent.kde.org/qt/clang/llvm-project/-/commit/298ee5b10407d114189e623636d613ad5e13f56e

Git commit 38517d91d15c6e0d969d1201367dfddaab9ae7ac by GitHub (on behalf of Adam Siemieniuk) on 17/08/2026 at 19:55..
[mlir][scf] Fully unroll SCF/Affine loops (#215220)

Adds a new transform op that fully unrolls given loops. Also, updates
'loop.unroll' documentation to better reflect its functionality.

A new op is added to avoid overloading and changing the default behavior
of the other existing unroll ops.
On its own, the new op complements the existing two transform ops and
mirrors available SCF/Affine utils.

Assisted-by: Copilot
https://invent.kde.org/qt/clang/llvm-project/-/commit/38517d91d15c6e0d969d1201367dfddaab9ae7ac

Git commit aa7316df2fc023efd9239bbf6d75853a5601d4c6 by GitHub (on behalf of Ellis Hoag) on 17/08/2026 at 19:56..
[NFC][MemProf] Replace MemProf binary with YAML (#216796)

Use `split-file` to inline the YAML into the test. Depends on
https://github.com/llvm/llvm-project/pull/216778.
https://invent.kde.org/qt/clang/llvm-project/-/commit/aa7316df2fc023efd9239bbf6d75853a5601d4c6

Git commit c86596f978479c2fdcb3b06ac5a893b66a4fd6d3 by GitHub (on behalf of Matt Arsenault) on 17/08/2026 at 19:59..
AMDGPU: Use mi_match in isFPExtFromF16OrConst (#216807)

Replace the getVRegDef + G_FPEXT/G_FCONSTANT opcode checks with m_GFPExt
and m_GFCst matchers. NFC.

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

Git commit 74bb5a3f3f9f3f23ec3d57da4c8f8a73a815585f by GitHub (on behalf of Andrei Elovikov) on 17/08/2026 at 19:59..
[VPlan][UTC] Number VPlan passes' instances in printing/filtering (#211424)

Allows to use UTC-generated CHECKs in more tests. First instance of a
given VPlan pass on a function doesn't have a number (would need
`-vplan-print-after=passName$`). Subsequent instances are numbered and
can be filtered as `-vplan-print-after=passName@2`.
https://invent.kde.org/qt/clang/llvm-project/-/commit/74bb5a3f3f9f3f23ec3d57da4c8f8a73a815585f

Git commit 9a1c6e5616971a90b5aab4068ac7680feb88cb4b by GitHub (on behalf of Erich Keane) on 17/08/2026 at 20:04..
[CIR] Fix array consts who change during layout (#216732)

The element types of an array can change for the purposes of lowering
depending on the contents of the initializer, particularly with unions.
This patch correctly mutates the array type such that it is either a
contiguous array (the correct way), or a struct that has the same
layout.
https://invent.kde.org/qt/clang/llvm-project/-/commit/9a1c6e5616971a90b5aab4068ac7680feb88cb4b

Git commit c130f0a47db3973de174b5643e88ef45f5b9941e by GitHub (on behalf of Shilei Tian) on 17/08/2026 at 20:16..
[AMDGPU][MC] Fix a crash when invalid SDWA encoding is used (#215140)

Fixes #215006.
https://invent.kde.org/qt/clang/llvm-project/-/commit/c130f0a47db3973de174b5643e88ef45f5b9941e

Git commit eddfe45aed546399a7579853a434f2e533be17bf by GitHub (on behalf of Matt Arsenault) on 17/08/2026 at 20:21..
AArch64: Fix csel-fold crash on an undef register (#216720)
https://invent.kde.org/qt/clang/llvm-project/-/commit/eddfe45aed546399a7579853a434f2e533be17bf

Git commit 53356c99b40042131d0942d817f823765b75f0f0 by GitHub (on behalf of Craig Topper) on 17/08/2026 at 20:31..
[RISCV] Use PatLeaf to reduce Xqcibi select and SFB patterns. NFC (#216451)

Assisted-by: Claude
https://invent.kde.org/qt/clang/llvm-project/-/commit/53356c99b40042131d0942d817f823765b75f0f0

Git commit f53b4d1bbecf83d272ee1f4a07609c1097f4ef5e by GitHub (on behalf of Tomer Shafir) on 17/08/2026 at 20:33..
[AArch64] Restrict FP imm ISel by accurate subtarget macro-fusion (#214849)

This patch improves the accuracy of FP immediate lowering for runtime
performance builds. Until now we relaxed the instruction count limit
from 2 to 4 merely based on the satisfaction of `ST.hasFuseLiterals`,
but this could be wrong for example false-positive for `MOVN`
instructions which would relax the limit but are not macro fused. Here
we check exactly if immediate materialization parts can be macro fused
using a new subtarget helper which is shared with macro-fusion.

It adds exhaustive test cases for all code sequences that
`isFPImmLegal()` can enable using `expandMOVImm()`. Including f32 as
regression tests - those cannot trigger a subtarget feature check,
because a f32 immed can always be materialized by up to 2 instructions
which is the default limit. As well as an optsize test with
representative test cases.

---------

Co-authored-by: Jon Roelofs <[email protected]>
https://invent.kde.org/qt/clang/llvm-project/-/commit/f53b4d1bbecf83d272ee1f4a07609c1097f4ef5e

Git commit 9353eddc544692cec9d3ac4d1f2a392a13300d6f by GitHub (on behalf of Chinmay Deshpande) on 17/08/2026 at 20:34..
[APFloat][SelectionDAG] Support Float8E5M3FNU in `convert.{to,from}.arbitrary.fp` (#216387)

Float8E5M3FNU was already accepted by the IR verifier, because
`isValidArbitraryFPFormat` is defined in terms of
`getArbitraryFPFormatSizeInBits` and that table covers it. It was
missing from `getArbitraryFPSemantics`, so `SelectionDAGBuilder`
rejected it with "not implemented format" and the verifier-clean IR
failed to compile. Add the mapping and the corresponding entries in the
`expandCONVERT_{TO,FROM}_ARBITRARY_FP` format allowlists.

Unlike every other format the expansions handle so far, Float8E5M3FNU is
unsigned: it has no sign bit, so all 8 bits go to a 5-bit exponent and a
3-bit significand.

Since an unsigned format cannot represent a negative value, a negative
input now saturates to zero when the saturate flag is set, and is poison
otherwise. -0.0 is excluded from that and still converts to +0, and the
check is ordered before the NaN case so a negative NaN still produces
the NaN encoding. APFloat treats constructing a negative value in an
unsigned semantics as unreachable, so there was no existing behaviour to
match.

AI disclosure: This PR was generated with the assistance of AI, and I
have reviewed it.
https://invent.kde.org/qt/clang/llvm-project/-/commit/9353eddc544692cec9d3ac4d1f2a392a13300d6f

Git commit 5a42ba2e052421a588c57db970bad3f6ea6011fa by GitHub (on behalf of Andy Kaylor) on 17/08/2026 at 20:43..
[LLVMABI][AARCH64] Add support for simple direct return case (#216437)

This adds LLVM ABI library support for AArch64 return type
classification for scalar and matrix types that are classified as
Direct. Other types and all arguments are now reported as not yet
implemented.

This also introduces the hook in Clang to use the ABI library for
non-Windows AArch64 targets when `-fexperimental-abi-lowering` is passed
and adds a test for the ABI handling of types which are handled by the
library.

Assisted-by: Cursor / various models
https://invent.kde.org/qt/clang/llvm-project/-/commit/5a42ba2e052421a588c57db970bad3f6ea6011fa

Git commit 1e1b09267034a6fe76024f58e13c08440aac6691 by GitHub (on behalf of Matt Arsenault) on 17/08/2026 at 20:48..
AArch64: Guard optimizeCondBranch against a physical copy source (#216699)

optimizeCondBranch walks COPY chains from the branch condition register,
calling getVRegDef on each copy's source operand. A COPY source can be a
physical register which doesn't make sense to pass to getVRegDef.

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

Git commit bf8c3e15a4202287c562d3045a1eddc84d16cf2d by GitHub (on behalf of Matt Arsenault) on 17/08/2026 at 20:48..
AMDGPU: Use mi_match for G_BITCAST check in RegBankLegalize (#216808)

Replace the getVRegDef + G_BITCAST opcode check in
tryEliminateReadAnyLane
with m_GBitcast. NFC.

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

Git commit b04bfb59acd79baff6f9f94d08c86dcd1cf77cb3 by GitHub (on behalf of Matt Arsenault) on 17/08/2026 at 20:49..
AMDGPU: Capture G_PTR_ADD flags via m_MIFlags in getBaseWithConstantOffset (#216809)

Read the nuw flag from the m_GPtrAdd match itself instead of a redundant
getVRegDef of the pointer register. NFC.

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

Git commit 3ec64dd5420f57abc780efa1bc935cfda02f6f8b by GitHub (on behalf of Katze719) on 17/08/2026 at 20:53..
[clang-format] Add support for additional C++ declaration specifiers in QualifierOrder (#160853)

Fixes #60866

This PR extends clang-formats `QualifierOrder` option to support
additional C++ declaration specifiers, addressing the limitation where
many common qualifiers were not recognized.

## Problem

Previously, `QualifierOrder` only supported a limited subset of C++
declaration specifiers:
- `const`, `volatile`, `static`, `inline`, `constexpr`, `restrict`,
`friend`

This meant that many common C++ qualifiers like `extern`, `mutable`,
`typedef`, `unsigned`, etc. were not recognized and could not be
properly reordered, limiting the usefulness of the feature.

## Solution

This PR adds support for 11 additional declaration specifiers:

**C++98/C99 specifiers:**
- `typedef` - Type definition specifier
- `extern` - External linkage specifier  
- `mutable` - Mutable member specifier
- `signed`, `unsigned` - Integer signedness specifiers
- `long`, `short` - Integer size specifiers

**C++11 specifiers:**
- `thread_local` - Thread-local storage duration specifier
- `explicit` - Explicit constructor/conversion specifier

**C++20 specifiers:**
- `consteval` - Immediate function specifier
- `constinit` - Constant initialization specifier
https://invent.kde.org/qt/clang/llvm-project/-/commit/3ec64dd5420f57abc780efa1bc935cfda02f6f8b

Git commit 9c139023cf2dd79cd1870766ba2118cb87f9bcf6 by GitHub (on behalf of Thurston Dang) on 17/08/2026 at 21:15..
[asan][test] Fix invalid-pointer-pairs-vector-extract.cpp breakage after #210729 (#216827)

compiler-rt/test/asan/TestCases/invalid-pointer-pairs-vector-extract.cpp
(introduced in #216532) started failing (or rather, unexpectedly
passing) after #210729 (e.g.,
https://lab.llvm.org/buildbot/#/builders/66/builds/35645,
https://lab.llvm.org/buildbot/#/builders/51/builds/42365), because it
changes the codegen for pointer subtraction if -fwrapv-pointer is not
set.

This patch fixes the test case by adding -fwrapv-pointer.
https://invent.kde.org/qt/clang/llvm-project/-/commit/9c139023cf2dd79cd1870766ba2118cb87f9bcf6

Git commit 91ba38d018aaf672fad6c7a41da8d725f659417f by GitHub (on behalf of Ebuka Ezike) on 17/08/2026 at 21:18..
[lldb] Fix SBValue.format property (#216802)

lldb.SBValue.format should map to GetFormat instead of GetName
https://invent.kde.org/qt/clang/llvm-project/-/commit/91ba38d018aaf672fad6c7a41da8d725f659417f

Git commit 3db5d1f5a42826b668c73b9b6cc58f70a22991cc by GitHub (on behalf of Mehdi Amini) on 17/08/2026 at 21:40..
[MLIR][SCF] Prioritize single-iteration loop inlining (#188986)

Loops with a statically known trip count of one expose a single acyclic
path and can be handled by the existing region branch op inliner.

Give that rewrite a higher benefit than the generic region branch op
canonicalizations. This ensures that the loop is inlined before dead
successor inputs can be removed independently and temporarily invalidate
the op under expensive pattern API checks.

This fixes some tests with MLIR_ENABLE_EXPENSIVE_PATTERN_API_CHECKS
enabled.

Assisted-by: Codex
https://invent.kde.org/qt/clang/llvm-project/-/commit/3db5d1f5a42826b668c73b9b6cc58f70a22991cc

Git commit 11e30159a3ab15be2582549b6d5f2d531861de33 by GitHub (on behalf of Daniel Chen) on 17/08/2026 at 21:46..
To fix test failures. (#216763)

This PR is to fix test failure in the AIX buildbot.
Flang supports 64-bit mode only. Add a config file to set OBJECT_MODE.
https://invent.kde.org/qt/clang/llvm-project/-/commit/11e30159a3ab15be2582549b6d5f2d531861de33

Git commit 1e127fa3ad8f36becc5db819a78f74f2b8e47d97 by GitHub (on behalf of Florian Hahn) on 17/08/2026 at 21:53..
[VPlan] Verify VPIRFlags when creating VPWidenRecipe. (#213039)

VPWidenRecipe's constructor didn't check its flags at all, unlike
VPInstruction and VPWidenCastRecipe. Add checks and fix remaining
violations.

PR: https://github.com/llvm/llvm-project/pull/213039
https://invent.kde.org/qt/clang/llvm-project/-/commit/1e127fa3ad8f36becc5db819a78f74f2b8e47d97

Git commit 8734e0798b1a5833a849acf81a23cc8bf53e2ad6 by GitHub (on behalf of Craig Topper) on 17/08/2026 at 22:10..
[RISCV] Simplify the SelectCompressOpt patterns. NFC (#216819)

Use a PatLeaf and a predicate to check the condition code instead of
having a SETEQ and SETNE pattern. CCtoRISCVCC will take care of
converting the condition code.
https://invent.kde.org/qt/clang/llvm-project/-/commit/8734e0798b1a5833a849acf81a23cc8bf53e2ad6

Git commit 5639cba92a088dc21e48d3e9b6b12e1b9abf230e by GitHub (on behalf of Valentin Clement (バレンタイン クレメン)) on 17/08/2026 at 22:21..
[flang][cuda] Allow call to len intrinsic on host with device argument (#216846)

This is fine to call `len` intrinsic on the host with a device actual
argument since the descriptor is allocated in managed memory.
https://invent.kde.org/qt/clang/llvm-project/-/commit/5639cba92a088dc21e48d3e9b6b12e1b9abf230e

Git commit 65f31e567b71aa6af09cf8456abd42591c1feac8 by GitHub (on behalf of Alex MacLean) on 17/08/2026 at 22:25..
[NVPTX] Add NewPM codegen pipeline (#215712)

This exactly mirrors the LegacyPM implementation and produces identical
PTX for all lit tests. Right now this is opt-in with `-enable-new-pm`
for llc and clang.
https://invent.kde.org/qt/clang/llvm-project/-/commit/65f31e567b71aa6af09cf8456abd42591c1feac8

Git commit ff9473661ec3452c0fc908f1f75ddff454fe7273 by GitHub (on behalf of Tom Stellard) on 17/08/2026 at 22:28..
workflows/new-prs: Limit token to current repository (#215406)

The token had access to all llvm repositories which was unnecessary
since it was only used for llvm-project.

https://github.com/llvm/llvm-project/security/code-scanning/1863
https://invent.kde.org/qt/clang/llvm-project/-/commit/ff9473661ec3452c0fc908f1f75ddff454fe7273

Git commit 8baae02766dfe3d9024145b385b55000bf333faa by GitHub (on behalf of Jackson Stogel) on 17/08/2026 at 22:36..
[libc][realpath][test] Allow test directory to contain symlinks (#216828)

CI for https://github.com/llvm/llvm-project/pull/212925 failed because
the `libc-riscv32-qemu-yocto-fullbuild-dbg` buildbot on Yocto uses a
symlink for `/tmp` to `/var/volatile/tmp`
([source](https://github.com/openembedded/openembedded-core/blob/07a342aa80c7349dd014f743a695a5e006add8df/meta/recipes-core/initscripts/initscripts-1.0/volatiles#L32)).
It's fair enough that a system may define `/tmp` as a symlink, so this
PR updates the realpath tests to call `realpath` on the test directory
to resolve symlinks.

This PR also updates the test to use `libc_make_test_file_path` instead
of `/tmp`. Previously, the tests used `/tmp` because
`libc_make_test_file_path` might have symlinks in it. Since we fully
resolve symlinks now, we can use the more standard approach now.
https://invent.kde.org/qt/clang/llvm-project/-/commit/8baae02766dfe3d9024145b385b55000bf333faa

Git commit 14c5af0659005a3c952aaee8aa06cb6b3e4271ab by GitHub (on behalf of Deric C.) on 17/08/2026 at 22:38..
[clang][HLSL] Complete the pattern an instantiation is built from, not the primary template (#216388)

Fixes https://github.com/llvm/llvm-project/issues/212575

When an external AST source lazily supplies class template patterns,
Clang stopped asking it for definitions once the primary pattern had
been completed. A partial specialization declared after that point is
then instantiated from a pattern that had never been defined, failing
with `err_template_instantiate_undefined`.
So whether a declaration compiled depended on what had been declared
before it (as seen in https://hlsl.godbolt.org/z/vW3xGY6sW).

The problem Is that `ClassTemplateSpecializationDecl::Create` copies the
`hasExternalLexicalStorage()` flag only from the primary template, and
only while the primary template was still incomplete. Partial
specializations therefore failed when the primary template was
completed, hence exhibiting the aforementioned
`err_template_instantiate_undefined` error behavior when the primary
template was completed.

To fix the issue, this PR replaces the logic in
`ClassTemplateSpecializationDecl::Create` (introduced by
https://github.com/llvm/llvm-project/commit/6e56d0dbe3c89d3cd5730a57b9049b74e0bf605f)
with a request for completion at the point the pattern is actually known
in `Sema::InstantiateClassTemplateSpecialization`. This PR also removes
the compensating logic that it had forced on
`HLSLExternalSemaSource::CompleteType`.

A unit test is added to `clang/unittests/AST/ExternalASTSourceTest.cpp`
to exercise such lazy template patterns, and an HLSL sema test has been
added to ensure that https://github.com/llvm/llvm-project/issues/212575
is properly fixed.

Assisted by: Claude Opus 5
https://invent.kde.org/qt/clang/llvm-project/-/commit/14c5af0659005a3c952aaee8aa06cb6b3e4271ab

Git commit e265316ec60b7e4aa29b3f224a1cc3baae4deca6 by GitHub (on behalf of Tom Stellard) on 17/08/2026 at 22:46..
workflows/release-binaries: Remove template expansion (#215405)

https://github.com/llvm/llvm-project/security/code-scanning/1699
https://invent.kde.org/qt/clang/llvm-project/-/commit/e265316ec60b7e4aa29b3f224a1cc3baae4deca6

Git commit e79b6156c3be973a017f9e3e6d2323d3e869b315 by GitHub (on behalf of Matt Arsenault) on 17/08/2026 at 22:55..
CodeGen: Fix MachineSink trivial coalescing crash on an undef register (#216632)

Fix unchecked getVRegDef use. Found by AI while working on something
else.

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

Git commit a5a79dd8faf387dcb61bc155635b2ee450b4585c by GitHub (on behalf of Finn Plummer) on 17/08/2026 at 23:00..
[DirectX] Prevent `dxil-resource-access` from entering an infinite phi loop  (#211345)

The pass will enter an infinite loop when collecting the handles if the
phi nodes loop: https://godbolt.org/z/77sr89oMj.

The pass will enter an infinite loop when trying to resolve the handle
index of a dynamic resource if the phi nodes loop:
https://godbolt.org/z/h4oW7Me5G.

This is resolved by updating `collectUsedHandles`/`getAccessIndices`
with a visited set of phi nodes.

Resolves, in part, https://github.com/llvm/llvm-project/issues/211121

Assisted by: Claude Opus 4.8
https://invent.kde.org/qt/clang/llvm-project/-/commit/a5a79dd8faf387dcb61bc155635b2ee450b4585c

Git commit fa4c6a65dc6a6825e0397eaf09f638ae53cf2c03 by GitHub (on behalf of Adrian Prantl) on 17/08/2026 at 23:08..
[lldb][RPC] Do not treat int8_t/uint8_t as strings (#216850)

`Char_S` and `Char_U` both denote a plain `char`; which of the two is
used depends on whether `char` is signed on the target. `SChar` and
`UChar` instead denote an explicitly signed or unsigned `char`, which is
how `int8_t`/`uint8_t` spell a byte buffer rather than a string.
Accepting those in TypeIsConstCharPtr truncates data at the first NUL
and produces a `const char *` where the API wants a `const uint8_t *`.
https://invent.kde.org/qt/clang/llvm-project/-/commit/fa4c6a65dc6a6825e0397eaf09f638ae53cf2c03

Git commit 738dc4f1a3b79bab9a7040e617e0a14dc78a7388 by GitHub (on behalf of Hari Limaye) on 17/08/2026 at 23:14..
[SLP] Add helper for accessing Tree Root (NFC) (#216783)

As an initial step towards supporting multiple Trees in the same
BoUpSLP, add a helper for accessing the Tree Root of VectorizableTree
and refactor code to use this.
https://invent.kde.org/qt/clang/llvm-project/-/commit/738dc4f1a3b79bab9a7040e617e0a14dc78a7388

Git commit 7ae6b349ed0c56e4e13f9e99fb85b30517af0a2e by GitHub (on behalf of Nico Weber) on 17/08/2026 at 23:18..
[gn build] Port 65f31e567b71 (#216873)
https://invent.kde.org/qt/clang/llvm-project/-/commit/7ae6b349ed0c56e4e13f9e99fb85b30517af0a2e

Git commit c62d02e01878f30f442bd08ab7f186dcacf0dbe5 by GitHub (on behalf of Nico Weber) on 17/08/2026 at 23:19..
[gn build] Port ca7ffcae3998 (#216874)
https://invent.kde.org/qt/clang/llvm-project/-/commit/c62d02e01878f30f442bd08ab7f186dcacf0dbe5

Git commit ef88ad6e6e381565e39c1e8c07d04d4da846a553 by GitHub (on behalf of Andres-Salamanca) on 17/08/2026 at 23:24..
[CIR] Add lowering for coroutine intrinsics and token none (#215709)

This patch adds CIRToLLVM lowering for coroutine intrinsics and token
none:

* `cir.token.none`
* `cir.coro.intrinsic.id`
* `cir.coro.intrinsic.alloc`
* `cir.coro.intrinsic.size`
* `cir.coro.intrinsic.begin`
* `cir.coro.intrinsic.free`
* `cir.coro.intrinsic.end`
https://invent.kde.org/qt/clang/llvm-project/-/commit/ef88ad6e6e381565e39c1e8c07d04d4da846a553

Git commit 403a6b5b496f1780b572254842eb90d439d24417 by GitHub (on behalf of Jackson Stogel) on 17/08/2026 at 23:41..
Reland "[libc] Add realpath to linux entrypoints" (#212925) (#216869)

This relands https://github.com/llvm/llvm-project/pull/212925 by
reverting commit efe96c53557041be11e7fb4d43e6448cc09f6062.

CI failures w/ `libc-riscv32-qemu-yocto-fullbuild-dbg` should have been
fixed by https://github.com/llvm/llvm-project/pull/216828.
https://invent.kde.org/qt/clang/llvm-project/-/commit/403a6b5b496f1780b572254842eb90d439d24417

Git commit f431b45638ecb29f838dd4c314aac36f8a30480b by GitHub (on behalf of Daniel Chen) on 17/08/2026 at 23:43..
[flang] Fix incorrect DSE of VALUE dummy arg copy stores due to TBAA mismatch (#215366)

Assisted by : IBM Bob

**Problem:**
When a BIND(C) derived-type dummy argument with the VALUE attribute is
large
enough to be passed on the stack (e.g. PPC64 byval ABI), Flang lowers it
as
a local `fir.alloca` with a `fir.declare` carrying
`fortran_attrs = value`. Before this fix, `AddAliasTags` classified
accesses
to that alloca under the `"allocated data"` TBAA subtree
(`SourceKind::Allocate`). However, other accesses to the same dummy
variable
were tagged under the `"dummy arg data"` subtree
(`SourceKind::Argument`).
Because these two subtrees are siblings under `"any data access"`,
LLVM's
`DSEPass` treated the copy-stores as non-aliasing with the subsequent
reads
and incorrectly eliminated them. At `-O3`, reads of the VALUE copy
returned
garbage, causing wrong results or `ERROR STOP`.

**Fix:**
in `AddAliasTags.cpp`, detect when a `SourceKind::Allocate` source is a
VALUE dummy arg copy by checking for
`fir::FortranVariableFlagsEnum::value`
on its `fir.declare`. Tag such accesses under `dummyArgDataTree` instead
of
`allocatedDataTree`, making them consistent with the dummy arg reads and
preventing DSE from eliminating the stores.

**Reproducer** (fails at `-O3`, passes at `-O0`, before fix):

```fortran
module m
  use ISO_C_BINDING
  type, bind(c) :: dtd0; integer(C_INT_LEAST8_T) :: a(10,5); end type
  type, bind(c) :: dtd1
    integer(C_INT_LEAST8_T) :: a(10,5); type(dtd0) :: d0
  end type
end module m
program p
  use m
  interface
    integer(C_INT_LEAST8_T) function fnt4(dt) bind(c)
      import; type(dtd1), value :: dt
    end function
  end interface
  type(dtd1) :: dtb; integer ret
  dtb%a = 1_1; dtb%d0%a = 1_1
  ret = fnt4(dtb)
end program p
integer(C_INT_LEAST8_T) function fnt4(dt) bind(c)
  use ISO_C_BINDING, only: C_INT_LEAST8_T
  use m, only: dtd0, dtd1
  type(dtd1), value :: dt
  do i = 1, 5; do j = 1, 10
    if (dt%a(j,i) /= 1) ERROR STOP 156
    dt%a(j,i) = 2
    if (dt%d0%a(j,i) /= 1) ERROR STOP 158
    dt%d0%a(j,i) = 2
  end do; end do
  fnt4 = 0
end function fnt4
https://invent.kde.org/qt/clang/llvm-project/-/commit/f431b45638ecb29f838dd4c314aac36f8a30480b

Git commit 85e76ec53ae4e5caea5a13b084c19ba4e2f3a6ce by GitHub (on behalf of Wael Yehia) on 17/08/2026 at 23:59..
[Driver] Treat -O4 as -O3 in clang::getOptimizationLevel, which is called when building LTO link command (#216450)

#169762 (commit e60a69ab8a9e7) replaced the -O option handling in
`tools::addLTOOptions` with `getOptimizationLevel()`, but
`getOptimizationLevel` doesn't expect -O4, while `addLTOOptions` used to
accept and without diagnostics. Teach `getOptimizationLevel` about -O4
and don't diagnose to revert to the old behavior.

---------

Co-authored-by: Wael Yehia <[email protected]>
https://invent.kde.org/qt/clang/llvm-project/-/commit/85e76ec53ae4e5caea5a13b084c19ba4e2f3a6ce

Git commit ecdcdf0577c18c327c5883d0fc1cee36a5cc6f1c by GitHub (on behalf of Dhruva Chakrabarti) on 18/08/2026 at 00:22..
[AMDGPU] Fix MIR test by adding stackPtrOffsetReg (#216866)

Otherwise, the test fails with expensive_checks.
https://invent.kde.org/qt/clang/llvm-project/-/commit/ecdcdf0577c18c327c5883d0fc1cee36a5cc6f1c

Git commit 9b2118c6439f8e4a8730f7bd080a322d6484c875 by GitHub (on behalf of Maksim Panchenko) on 18/08/2026 at 01:18..
[BOLT][AArch64] Add call relaxation pass (#173952)

Add a function call relaxation pass that groups functions into clusters,
each with a maximum size of 128MB. This pass is enabled using the
`--relax-exp` option.

* Within each cluster: function calls do not require relaxation.

* Between clusters: thunks are created at the cluster boundaries to
handle inter-cluster calls. These thunks can be either short or long,
depending on the proximity of the thunk destination. When possible, a
long thunk may be shared by both adjacent clusters.

* Hot functions: if all hot functions (after reordering) fit within a
single cluster (under 128MB), no thunks are needed on the hot path, as
determined by the profile.

* PLT behavior: for the Procedure Linkage Table (PLT), it is currently
assumed that the hottest cluster will be placed adjacent to the PLT, so
thunks are not required for that cluster. This assumption can be
disabled with `--relax-plt=0` option.

* Pass behavior: when enabled, this pass replaces the LongJmp pass. It
typically runs much faster because it does not attempt to predict the
exact code layout.

* Local function branches are relaxed using the compact code model
(`--compact-code-model`).
https://invent.kde.org/qt/clang/llvm-project/-/commit/9b2118c6439f8e4a8730f7bd080a322d6484c875

Git commit 7b2a985ff522b15669c238b5c8866eb9dd25caf1 by GitHub (on behalf of MrEven132) on 18/08/2026 at 01:53..
[lldb] Keep DW_OP_fbreg results address-sized (#216641)

DW_OP_fbreg adds its signed displacement as an int64_t, which can widen
a 32-bit frame-base Scalar to 64 bits. Canonicalize the pushed result
using the evaluator's existing generic conversion so subsequent
arithmetic uses the target address width.

Add an i386 regression test that checks 32-bit wrapping and the
resulting APSInt width.

Fixes #211007
https://invent.kde.org/qt/clang/llvm-project/-/commit/7b2a985ff522b15669c238b5c8866eb9dd25caf1

Git commit 93030c36edb97a9efeca32eea9a8ca0c27a6be1a by GitHub (on behalf of Benji Smith) on 18/08/2026 at 01:54..
[SDAG] Fix invalid sign bit condition for abs(sub) -> abdu fold (#215548)

The fold here for (abs (sub x y)) -> (abdu x y) was proven in Alive,
assuming that both operands had a sign bit of zero. However, the code
was checking if x had a sign bit of zero and y had a sign bit of 1

Fixes https://github.com/llvm/llvm-project/issues/214942

Original Alive proof from
https://github.com/llvm/llvm-project/pull/186659 :
https://alive2.llvm.org/ce/z/HfPF5q
A variant that's explicitly (abs (sub x y)):
https://alive2.llvm.org/ce/z/QEgDaa
And changing the range to 32770 or higher there will break the
transformation
https://invent.kde.org/qt/clang/llvm-project/-/commit/93030c36edb97a9efeca32eea9a8ca0c27a6be1a

Git commit 0207706de3019c5a2fbb811bebefcf1305a7cd34 by GitHub (on behalf of KAWASHIMA Takahiro) on 18/08/2026 at 01:58..
[orc-rt] Add missing `#include <optional>` (#216894)
https://invent.kde.org/qt/clang/llvm-project/-/commit/0207706de3019c5a2fbb811bebefcf1305a7cd34

Git commit 23b24af6a021c12c670203678ec4911fa8b03f29 by GitHub (on behalf of Anutosh Bhat) on 18/08/2026 at 02:18..
[WebAssembly] Add v8f16 select instruction patterns (#213280)

I see the following 

```
 anutosh491@Anutoshs-MacBook-Air llvm-project % cat /private/tmp/wasm-f16-select.ll
define <8 x half> @select_v8f16(i1 %cond, <8 x half> %a, <8 x half> %b) {
  %result = select i1 %cond, <8 x half> %a, <8 x half> %b
  ret <8 x half> %result
}
```
```

 anutosh491@Anutoshs-MacBook-Air llvm-project % build-assert/bin/llc \             
  -mtriple=wasm32-unknown-unknown \
  -mattr=+simd128,+fp16 \
  -o /dev/null \
  /private/tmp/wasm-f16-select.ll
LLVM ERROR: Cannot select: t8: v8f16 = select t12, t4, t6
  t12: i32 = and t2, Constant:i32<1>
    t2: i32 = WebAssemblyISD::ARGUMENT TargetConstant:i32<0>
  t4: v8f16 = WebAssemblyISD::ARGUMENT TargetConstant:i32<1>
  t6: v8f16 = WebAssemblyISD::ARGUMENT TargetConstant:i32<2>
In function: select_v8f16
PLEASE submit a bug report to https://github.com/llvm/llvm-project/issues/ and include the crash backtrace and instructions to reproduce the bug.
Stack dump:
0. Program arguments: build-assert/bin/llc -mtriple=wasm32-unknown-unknown -mattr=+simd128,+fp16 -o /dev/null /private/tmp/wasm-f16-select.ll
1. Running pass 'Function Pass Manager' on module '/private/tmp/wasm-f16-select.ll'.
2. Running pass 'WebAssembly Instruction Selection' on function '@select_v8f16'
   #0 0x0000000103c6852c llvm::sys::PrintStackTrace(llvm::raw_ostream&, int) (/Users/anutosh491/work/llvm-project/build-assert/bin/llc+0x1030e852c)
   #1 0x0000000103c66208 llvm::sys::RunSignalHandlers() (/Users/anutosh491/work/llvm-project/build-assert/bin/llc+0x1030e6208)
   #2 0x0000000103c69130 SignalHandler(int, __siginfo*, void*) (/Users/anutosh491/work/llvm-project/build-assert/bin/llc+0x1030e9130)
   #3 0x000000018b5f7744 (/usr/lib/system/libsystem_platform.dylib+0x1804fb744)
   #4 0x000000018b5ed8d8 (/usr/lib/system/libsystem_pthread.dylib+0x1804f18d8)
   #5 0x000000018b4f4644 (/usr/lib/system/libsystem_c.dylib+0x1803f8644)
   #6 0x0000000103bbc0b4 llvm::report_fatal_error(llvm::Twine const&, bool) (/Users/anutosh491/work/llvm-project/build-assert/bin/llc+0x10303c0b4)
   #7 0x0000000103af91b8 llvm::SelectionDAGISel::CannotYetSelect(llvm::SDNode*) (/Users/anutosh491/work/llvm-project/build-assert/bin/llc+0x102f791b8)
   #8 0x0000000103af813c llvm::SelectionDAGISel::SelectCodeCommon(llvm::SDNode*, unsigned char const*, unsigned int, unsigned char const*) (/Users/anutosh491/work/llvm-project/build-assert/bin/llc+0x102f7813c)
   #9 0x0000000101f66b78 (anonymous namespace)::WebAssemblyDAGToDAGISel::Select(llvm::SDNode*) (/Users/anutosh491/work/llvm-project/build-assert/bin/llc+0x1013e6b78)
#10 0x0000000103aee46c llvm::SelectionDAGISel::DoInstructionSelection() (/Users/anutosh491/work/llvm-project/build-assert/bin/llc+0x102f6e46c)
#11 0x0000000103aed400 llvm::SelectionDAGISel::CodeGenAndEmitDAG() (/Users/anutosh491/work/llvm-project/build-assert/bin/llc+0x102f6d400)
#12 0x0000000103aeb4b4 llvm::SelectionDAGISel::SelectAllBasicBlocks(llvm::Function const&) (/Users/anutosh491/work/llvm-project/build-assert/bin/llc+0x102f6b4b4)
#13 0x0000000103ae8ba8 llvm::SelectionDAGISel::runOnMachineFunction(llvm::MachineFunction&) (/Users/anutosh491/work/llvm-project/build-assert/bin/llc+0x102f68ba8)
#14 0x0000000103ae6cd8 llvm::SelectionDAGISelLegacy::runOnMachineFunction(llvm::MachineFunction&) (/Users/anutosh491/work/llvm-project/build-assert/bin/llc+0x102f66cd8)
#15 0x0000000102b71d28 llvm::MachineFunctionPass::runOnFunction(llvm::Function&) (/Users/anutosh491/work/llvm-project/build-assert/bin/llc+0x101ff1d28)
#16 0x0000000103096900 llvm::FPPassManager::runOnFunction(llvm::Function&) (/Users/anutosh491/work/llvm-project/build-assert/bin/llc+0x102516900)
#17 0x000000010309cc00 llvm::FPPassManager::runOnModule(llvm::Module&) (/Users/anutosh491/work/llvm-project/build-assert/bin/llc+0x10251cc00)
#18 0x0000000103097174 llvm::legacy::PassManagerImpl::run(llvm::Module&) (/Users/anutosh491/work/llvm-project/build-assert/bin/llc+0x102517174)
#19 0x0000000100b880a4 main (/Users/anutosh491/work/llvm-project/build-assert/bin/llc+0x1000080a4)
#20 0x000000018b22fe00
zsh: abort      build-assert/bin/llc -mtriple=wasm32-unknown-unknown -mattr=+simd128,+fp16 -o

```
https://invent.kde.org/qt/clang/llvm-project/-/commit/23b24af6a021c12c670203678ec4911fa8b03f29

Git commit 763aec0170ee5f049d86156295c0aa9801c19377 by GitHub (on behalf of satyanarayana reddy janga) on 18/08/2026 at 02:19..
[lldb] Adopt ProcessAddress in the read memory APIs (NFC) (#214088)

Relevant RFC:
https://discourse.llvm.org/t/rfc-address-spaces-support-in-lldb/91222/

Previous PR  #206370  adding the AddressSpace definitions. 


- switches the read memory virtuals from lldb::addr_t to const
ProcessAddress & and updates every override. No behavior change
expected.
 

**Test Plan**
- Depending on the buildbots for all other platforms.
https://invent.kde.org/qt/clang/llvm-project/-/commit/763aec0170ee5f049d86156295c0aa9801c19377

Git commit 7a129526e98e1bd6dbc59c643e4d6496cc9d7b13 by GitHub (on behalf of Fangrui Song) on 18/08/2026 at 02:42..
[BFI] Solve irreducible SCCs instead of splitting their headers (#215170)

c5a3139ebd0d (2014) approximates irreducible control flow by modelling
an SCC as a loop with multiple headers, and
http://reviews.llvm.org/D10348 re-distributes the loop mass across those
headers in proportion to the backedge mass each one received -- one step
of a power iteration, from an assumed split.

Package the SCC with a single representative and solve it instead.
`solveIrreducibleMass` iterates the SCC's internal chain towards its
dominant eigenvector and reads the member masses, the exits and the
circulating mass off that, so the entries' relative frequencies come out
of the solve.  Power iteration rather than a relaxation of `f = e +
f*P`: the mass `e` entering the SCC is unknown here, so there is no
fixed point to relax towards, only a direction.  NumHeaders, the
per-header BackedgeMass, getHeaderIndex, the isHeader binary search and
adjustLoopHeaderMass go away with the split.

Relative error against an exact rational solve has improved.

```
          higher is better             |  relative error (lower is better)
          exact  within 1%  within 10% |   p50    p90     max
before       93        111         118 |  0.99   5.27   521.6
after        93        112         129 |  0.77   2.40    46.2
```

Among the lit tests, selfloops and unequalrows converge to their exact
ratios, and nonentry's worst block is off by 1.9x rather than 31.5x.

Bound the iteration rather than run it to convergence: a periodic SCC
oscillates and never terminates, and over that corpus the error
distribution is the same at 16 iterations as at 1000, moving
non-monotonically in between.  The work is bounded by the size of the
SCC rather than by the function.

This does not subsume -use-iterative-bfi-inference (0a0800c4d10c), which
relaxes the same equations over the whole function, where the entry mass
is known.  On yyparse_1 in profile-correlation-irreducible-loops.ll the
solve alone puts b2 at 2.1x the entry against an exact 586.19x, and
inference reaches 586.19x either way.  Over the corpus above the two
stack: enabling inference takes within 10% from 118 to 137 functions
before this patch and from 129 to 144 after.

CFGMST weights edges by BFI, so the instrumentation counter indices
permute.  Re-record Inputs/irreducible{,_entry}.proftext under the new
numbering; the block counts the tests check are unchanged.

LLM-assisted
https://invent.kde.org/qt/clang/llvm-project/-/commit/7a129526e98e1bd6dbc59c643e4d6496cc9d7b13

Git commit b84b33d533b1ca706c61a7fc13cda6eeaa628f55 by GitHub (on behalf of Valentin Clement (バレンタイン クレメン)) on 18/08/2026 at 02:59..
[flang][cuda] Add option to emit different function name for alloc/free of descriptors (#216841)

This allow to call specialized functions instead of the upstream ones.
https://invent.kde.org/qt/clang/llvm-project/-/commit/b84b33d533b1ca706c61a7fc13cda6eeaa628f55

Git commit 9089be3caf952d1410287ba88b8debfd931a4d5c by GitHub (on behalf of Valentin Clement (バレンタイン クレメン)) on 18/08/2026 at 03:00..
[flang][cuda] Add support for custom descriptor allocator in codegen (#216881)

Simlar to https://github.com/llvm/llvm-project/pull/216841 but for
CodeGen pass usage.
https://invent.kde.org/qt/clang/llvm-project/-/commit/9089be3caf952d1410287ba88b8debfd931a4d5c

Git commit 703f0ae7e68f3cbb3679aef3ac4079d9d4ca3e52 by GitHub (on behalf of Kazu Hirata) on 18/08/2026 at 03:04..
[ADT] Remove CRTP from FoldingSet and ContextualFoldingSet (NFC) (#216830)

This patch simplifies FoldingSet by removing CRTP from FoldingSet and
ContextualFoldingSet.

Without this patch, FoldingSetImpl uses CRTP to get FoldingSetInfo, a
custom "vtable", from FoldingSet and ContextualFoldingSet.

With this patch, we put ContextStorage as the base class of
FoldingSetImpl.  FoldingSetImpl directly takes FoldingSetTrait as a
template parameter.  This allows us to:

- populate FoldingSetInfo for both FoldingSet and
  ContextualFoldingSet as a static constexpr variable.

- rely on the empty base optimization (EBO) on ContextStorage so that
  FoldingSet incurs no memory overhead.

- turn FoldingSet and ContextualFoldingSet into simple type aliases of
  FoldingSetImpl.

Assisted-by: Antigravity
https://invent.kde.org/qt/clang/llvm-project/-/commit/703f0ae7e68f3cbb3679aef3ac4079d9d4ca3e52

Git commit da9c02442bc32cf2917f944d9238a45bb12ab14d by GitHub (on behalf of Kazu Hirata) on 18/08/2026 at 03:04..
[Support] Remove duplicate comments in FoldingSet.cpp (NFC) (#216833)

This patch removes duplicate comments in FoldingSet.cpp.
Corresponding declarations are already documented in FoldingSet.h.

Note that LLVM Coding Standards state:

  Don't duplicate the documentation comment in the header file and in
  the implementation file. Put the documentation comments for public
  APIs into the header file.
https://invent.kde.org/qt/clang/llvm-project/-/commit/da9c02442bc32cf2917f944d9238a45bb12ab14d

Git commit fe17ff63234eb8a321befd92982106e562b3057c by GitHub (on behalf of Shilei Tian) on 18/08/2026 at 03:22..
[NVPTX] Fix link error when building LLVM with dylib (#216898)
https://invent.kde.org/qt/clang/llvm-project/-/commit/fe17ff63234eb8a321befd92982106e562b3057c

Git commit d7d525e0b66bed110865999a32e7d2772fa573d0 by GitHub (on behalf of Jiahao Guo) on 18/08/2026 at 03:28..
[CIR][AArch64] Lower NEON Saturating substract intrinsics (#207189)

### Summary

part of : https://github.com/llvm/llvm-project/issues/185382

Lower intrinsics with out SISD in :
https://arm-software.github.io/acle/neon_intrinsics/advsimd.html#saturating-subtract

- Vector forms (vqsub{q}_{s,u}{8,16,32,64} - 16): added vqsub_v/vqsubq_v
to the existing vshl_v intrinsic-call block in
emitCommonNeonBuiltinExpr; signedness picks sqsub/uqsub via the
UnsignedAlts alternates.

Assisted by : Claude Opus4.8
https://invent.kde.org/qt/clang/llvm-project/-/commit/d7d525e0b66bed110865999a32e7d2772fa573d0

Git commit b1550b180af0144475ccb6c8b4782c2a30de29b3 by GitHub (on behalf of Kiva) on 18/08/2026 at 03:43..
[InstCombine] Use samesign constraints in unsigned known-bits folds (#209675)

Extracted from #209097 during review.

For a non-poison unsigned `icmp samesign`, both operands have the same
sign bit. Propagate a known sign bit between the temporary `KnownBits`
values in `foldICmpUsingKnownBits()` so the existing range folds can use
this constraint.

This enables endpoint folds in both signed halves of the integer range,
for example:

```
icmp samesign ugt i8 %x, 126 -> icmp eq i8 %x, 127
icmp samesign ult i8 %x, 127 -> icmp ne i8 %x, 127
icmp samesign ugt i8 %x, -2  -> icmp eq i8 %x, -1
```

-------------------------------

Although propagating the sign constraint is sound for any non-poison
icmp samesign, applying it to signed and equality predicates is
unnecessarily aggressive here. `foldICmpUsingKnownBits()` may refine
such a comparison in isolation before higher-level select or logical
combines can recognize a better canonical form. This caused an
instruction-count regression:

```
%masked = and i32 %a, -1073741825
%cmp1 = icmp eq i32 %masked, 0
%cmp2 = icmp samesign sgt i32 %a, -1
%result = select i1 %cmp1, i1 true, i1 %cmp2
ret i1 %result
```

Without the restriction, the known-bits fold observes that a non-poison
%cmp2 constrains %a to be negative and folds %cmp2 to false. The
surrounding select then becomes:

```
%masked = and i32 %a, -1073741825
%cmp1 = icmp eq i32 %masked, 0
ret i1 %cmp1
```

The existing canonical result is the cheaper one-instruction sign test:

```
%cmp = icmp sgt i32 %a, -1
ret i1 %cmp
```

Therefore I restricted sign propagating to only I.hasSameSign() &&
I.isUnsigned() to avoid such regression.
https://invent.kde.org/qt/clang/llvm-project/-/commit/b1550b180af0144475ccb6c8b4782c2a30de29b3

Git commit 8488a831442940a6412ea9a4d4af2139ffde3567 by GitHub (on behalf of Zachary Yedidia) on 18/08/2026 at 03:53..
[LFI][X86] Enable bundling for the LFI target (#214111)

This enables 32-byte bundling for the LFI x86-64 target, and uses bundle
grouping for existing rewrites where appropriate.
https://invent.kde.org/qt/clang/llvm-project/-/commit/8488a831442940a6412ea9a4d4af2139ffde3567

Git commit fcce92173cb6b87ad82b9debda13b4de256dfdfa by GitHub (on behalf of Timm Baeder) on 18/08/2026 at 04:19..
[clang][bytecode] Check for invalid RecordDecls in Pointer::toAPValue() (#216537)

We can't pass forward declarations to ASTContext::getRecordLayout().
https://invent.kde.org/qt/clang/llvm-project/-/commit/fcce92173cb6b87ad82b9debda13b4de256dfdfa

Git commit 5eeda7209ec867409a61d4caddd90db2abee1488 by GitHub (on behalf of Craig Topper) on 18/08/2026 at 04:24..
[RISCV] Use PatLeaf to simplify XAndes and XCV select patterns. NFC (#216839)
https://invent.kde.org/qt/clang/llvm-project/-/commit/5eeda7209ec867409a61d4caddd90db2abee1488

Git commit f3bc5801e20ce00feb55313735d7ee6b4d62bb23 by GitHub (on behalf of Timm Baeder) on 18/08/2026 at 04:56..
[clang][bytecode] Add `Pointer::getRootExpr()` (#216706)

Similarly to `getRootVarDecl()`, returns the expression of the base of
the pointer, if there is such an expression.
https://invent.kde.org/qt/clang/llvm-project/-/commit/f3bc5801e20ce00feb55313735d7ee6b4d62bb23

Git commit ca1719f53af44357ad1246847a8e239f5c949270 by GitHub (on behalf of Arseniy Obolenskiy) on 18/08/2026 at 05:44..
[clang][SPIR-V] Remove CC_SpirFunction calling convention (#216252)

CC_SpirFunction is now redundant: CC_C already lowers to spir_func on
SPIR/SPIR-V targets, after
https://github.com/llvm/llvm-project/pull/210882
https://invent.kde.org/qt/clang/llvm-project/-/commit/ca1719f53af44357ad1246847a8e239f5c949270

Git commit d5ff5c4f4e6cdf5d57f009bc83288b63c8b80c8b by GitHub (on behalf of Matt Arsenault) on 18/08/2026 at 06:10..
RISCV: Fix using getVRegDef on a physical register (#216749)
https://invent.kde.org/qt/clang/llvm-project/-/commit/d5ff5c4f4e6cdf5d57f009bc83288b63c8b80c8b

Git commit fd5d289302931aea700429dd90d3f004117a4d7e by GitHub (on behalf of Matt Arsenault) on 18/08/2026 at 06:11..
CodeGen: Fix machine sink critical edge crash on an undef register (#216870)
https://invent.kde.org/qt/clang/llvm-project/-/commit/fd5d289302931aea700429dd90d3f004117a4d7e

Git commit 5ff04f61ece988c1897c0b4b6715bb7a2fc532dd by GitHub (on behalf of Bryth) on 18/08/2026 at 06:14..
[mlir][ComplexToStandard] fix typo in complex sine comment (NFC) (#216738)
https://invent.kde.org/qt/clang/llvm-project/-/commit/5ff04f61ece988c1897c0b4b6715bb7a2fc532dd

Git commit a28c0287001fd4718583fff7128283b0c80ee102 by GitHub (on behalf of Craig Topper) on 18/08/2026 at 06:19..
[RISCV] Query sched_getaffinity before hwprobe for -mcpu=native (#216886)

Heterogenous CPUs like the SpacemiT K3 have a different marchid/mimpid
on different cores. The previous code asked for the common marchid/mimpid
amongst all CPUs. This will return -1 since they don't match across all
CPUs.

This patch uses sched_getaffinity to get the CPUs the compiler is
running on. If the process has been restricted to either the X100 or
A100 cores, this will allow us to get the marchid/mimpid for just those
cores.
https://invent.kde.org/qt/clang/llvm-project/-/commit/a28c0287001fd4718583fff7128283b0c80ee102

Git commit d37b02cbefc01d2fe5149e148c8edfbd72d9ed08 by GitHub (on behalf of Pavel Labath) on 18/08/2026 at 06:25..
[libc] Drop .unit/.hermetic suffix from test support libraries (#216689)

This is not necessary now that we only build one kind of a test in a
given build configuration. This also makes it easier to convert to
something closer to how other libc libraries work.
https://invent.kde.org/qt/clang/llvm-project/-/commit/d37b02cbefc01d2fe5149e148c8edfbd72d9ed08

Git commit ebd743c2dc77a1bcbcf6aa5c14cdd57a2735bae4 by GitHub (on behalf of hanbeom) on 18/08/2026 at 06:26..
[VectorCombine] Handle frees and synchronization in single element stores (#216562)

foldSingleElementStore only checked whether intervening instructions modified
the stored memory. Calls that may free or synchronize could therefore make
scalarization incorrect.

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

Git commit 74231004d4f45ee3942b2b7114da58b6d59cb01e by GitHub (on behalf of Emery Conrad) on 18/08/2026 at 06:28..
Reland "[ORC] Track __emutls_t definitions in IRMaterializationUnit" (#207161) (#209717)

Relands #207161 (the `IRMaterializationUnit::discard` fix for duplicated
`__emutls_t.<var>` symbols). History: #207161 merged, reverted in
#207775,
relanded in #208413, reverted again in #209260 (a day before the 23.x
cut).

### Why #208413 was reverted

clang-repl's JIT lowers `thread_local` to emulated TLS on every target
(`JITTargetMachineBuilder` forces `EmulatedTLS`), so JIT'd code always
references `__emutls_get_address`. #208413 only made that symbol
resolvable on
Darwin (`#ifdef __APPLE__` + `isOSBinFormatMachO()`), where it lives in
the
compiler-rt builtins static archive. The same gap exists on any host
that
links compiler-rt builtins instead of libgcc_s: the arm-toolchain CI hit
it on
Linux/AArch64 built with `-rtlib=compiler-rt` (no libgcc_s), where
`__emutls_get_address` is only in the static archive and process-symbol
lookup
cannot find it — `JIT session error: Symbols not found: [
__emutls_get_address ]`.
(glibc bots pass because libgcc_s.so exports it.)

### This reland

The `IRMaterializationUnit` fix (`Layer.cpp`) and the test are unchanged
from
#208413. The `IncrementalExecutor.cpp` workaround is broadened from
Darwin-only
to all in-process Unix hosts:

- reference `__emutls_get_address` under `LLVM_ON_UNIX` (excluding
Emscripten,
AIX, and z/OS) to force-link it from whichever compiler runtime the
toolchain
  uses (libgcc_s or the compiler-rt builtins archive), and
- define it as an absolute symbol in the process-symbols JITDylib
regardless of
  target binary format.

This is target-independent: emulated-TLS lowering emits the accessor
name from
shared codegen (`TargetLowering`), so a single symbol covers every arch.
The
previous `isOSBinFormatMachO()` guard is dropped — with emulated TLS
forced on,
a target-format check is vestigial and can only re-exclude the exact
hosts that
fail. Where process-symbol lookup already resolves the symbol (glibc),
the
absolute definition is a harmless shadow (an already-defined symbol is
dropped
from generation candidates before the process-symbol generator runs),
following
the MinGW `__main` precedent in `lli.cpp`. In-process only — a host
address is
meaningless for an out-of-process executor. The `UNSUPPORTED:
target=loongarch`
line from #208886 is retained (LoongArch rejects emulated TLS outright).

The reference resolves from the toolchain's compiler runtime; hosts with
no
guaranteed emulated-TLS runtime on the link line (MSVC, Emscripten, AIX,
z/OS)
are excluded and fall back to process-symbol lookup, as before.

### Alternatives considered

- **Load the compiler-rt builtins archive into a JITDylib** (via a
static-library definition generator, as `lli --extra-archive` does)
instead of
  force-linking + defining the symbol. This avoids the build-time link
dependency and generalizes to other builtins, at the cost of runtime
discovery
of the builtins archive path (resource dir / sysroot / cross-compiles /
libgcc-only toolchains) plus plumbing to reach the in-process JIT path.
It's a
reasonable alternative and a clean follow-on; this PR takes the smaller,
target-independent route to get the discard fix relanded, and I'm happy
to
  switch to it if reviewers prefer.
- **Native TLS + the ORC runtime** — the long-term fix (also removes the
in-process-only constraint), tracked by the TODO added next to the
workaround.
  Out of scope here.

### Testing

Verified on Linux/x86-64: full `check-clang` clean;
`clang/test/Interpreter/emulated-tls.cpp`
passes. Darwin verified by the author on aarch64.

🤖 Done with the help of [Claude Code](https://claude.com/claude-code)
(Claude Opus 4.8, human in the loop)

Co-authored-by: Emery Conrad <[email protected]>
https://invent.kde.org/qt/clang/llvm-project/-/commit/74231004d4f45ee3942b2b7114da58b6d59cb01e

Git commit 6394197d7698f28b5a4a5e991228985163d1fd0c by GitHub (on behalf of DmitriiMartynov) on 18/08/2026 at 06:36..
[BOLT] Fix test for systems where dl/pthread are not part of libc (#206944)

The bolt/test/runtime/setup-race.cpp test (including the original one)
crashes with a segfault on Ubuntu 20.04 (glibc 2.31) because the dlsym
symbol is not found.
According to the glibc 2.34 release notes, libpthread, libdl, libutil,
and libanl have been integrated into libc. For older glibc versions, it
is still necessary to link against libdl (for dlsym) and libpthread (for
pthread_* symbols).
https://invent.kde.org/qt/clang/llvm-project/-/commit/6394197d7698f28b5a4a5e991228985163d1fd0c

Git commit 5d49857aa11b65483233d3909e611c2969f2c729 by GitHub (on behalf of Jan Svoboda) on 18/08/2026 at 06:48..
[clang][lex] Do not translate repeated include into import (#216704)

Using `ModuleToImport` when deciding whether to turn a repeated include
into an import, or whether to skip it, isn't right. We have
`ModuleToImport=true` even without `-fmodules` in textual compilations.
This PR starts checking `UsableClangHeaderModule`, matching what we do
for the first inclusion of that header.

rdar://184549117
https://invent.kde.org/qt/clang/llvm-project/-/commit/5d49857aa11b65483233d3909e611c2969f2c729

Git commit df50dc974cf67223350e737665edfa14ef05d11b by GitHub (on behalf of Lang Hames) on 18/08/2026 at 06:49..
[ORC] Share memory-map bindings between their two clients (#216911)

SimpleMemoryMapBindings holds an executor-side memory manager's instance
address and a Proxy per operation: reserve, initialize, deinitialize,
release. EPCGenericJITLinkMemoryManager and SimpleRemoteMemoryMapper
both take one, so the operations are described once rather than per
client.

SimpleRemoteMemoryMapper previously held a SymbolAddrs struct and made
raw EPC.callSPSWrapperAsync calls. Going through proxies drops the
per-call serialization-error plumbing, since Proxy already folds that
into the result.

sps::createSimpleMemoryMapBindings resolves the bindings with a single
lookup, under the specs' default (SimpleNativeMemoryMap) names. The
specs move out of EPCGenericJITLinkMemoryManagerSPS.h alongside the
bindings, as they describe the interface rather than either client.

llvm-jitlink's simple-remote memory manager uses that instead of reading
the legacy SimpleExecutorMemoryManager* names out of the bootstrap
symbol map.
https://invent.kde.org/qt/clang/llvm-project/-/commit/df50dc974cf67223350e737665edfa14ef05d11b

Git commit 90c0c675b463b7aaace2c9f90dfe7fc4f851678c by GitHub (on behalf of David Green) on 18/08/2026 at 07:11..
[AArch64] Do not allow anyext load in isEquivalentMaskless (#216288)

isEquivalentMaskless tries to prove that the `and` in `cmp(and(add(x,
C1), 0xff), C2)` is redundant and can be removed, providing that the
input x is know to be a sext or zext. AFAICT it should not apply to
anyext, which could take any value.

Fixes #215839
https://invent.kde.org/qt/clang/llvm-project/-/commit/90c0c675b463b7aaace2c9f90dfe7fc4f851678c

Git commit 94f597cee5b8058ca16d679b10a2cfd5a191f4e7 by GitHub (on behalf of Lang Hames) on 18/08/2026 at 07:27..
[orc-rt] Add clarifying note to BootstrapInfo::CreateDefault (#216936)

NFC.
https://invent.kde.org/qt/clang/llvm-project/-/commit/94f597cee5b8058ca16d679b10a2cfd5a191f4e7

Git commit ddda6903e9d10cd8b835edd5be5e5c7d3e9c6c83 by GitHub (on behalf of Hsiangkai Wang) on 18/08/2026 at 08:01..
[mlir][spirv] Mark in-bounds linearized indices no-wrap (#215834)

Preserve signed and unsigned no-wrap guarantees for statically bounded
SPIR-V index linearization, allowing buffer address arithmetic to be
reassociated safely.
https://invent.kde.org/qt/clang/llvm-project/-/commit/ddda6903e9d10cd8b835edd5be5e5c7d3e9c6c83

Git commit de7cacd2406aa805a463f26563b4f55811842ba0 by GitHub (on behalf of Zorojuro) on 18/08/2026 at 08:15..
[libc] Modify `floorf128` to use emulated Float128 type (#216552)
https://invent.kde.org/qt/clang/llvm-project/-/commit/de7cacd2406aa805a463f26563b4f55811842ba0

Git commit fe7038b79dcd3a47306b6586b306cf9963d3bc8c by GitHub (on behalf of Matt Arsenault) on 18/08/2026 at 08:21..
GlobalISel: Add m_PosZeroFP matcher and use it in AArch64 selector (#216925)

Add an FP-constant predicate matcher m_PosZeroFP, mirroring the IR
PatternMatch helper, and use it in emitFPCompare instead of binding the
ConstantFP just to test for +0.0. NFC.

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

Git commit da1fb5cf9675ffbb19079e776f5d7acc963623ff by GitHub (on behalf of xYtty) on 18/08/2026 at 08:31..
[llvm-readobj] Improve unsupported option messages (#216488)

Improve the messages for unsupported options when using GNU output
style.
Fixes #51294.
https://invent.kde.org/qt/clang/llvm-project/-/commit/da1fb5cf9675ffbb19079e776f5d7acc963623ff

Git commit 836904b855586881f2b72f23ed18c68656b9d728 by Pengcheng Wang on 18/08/2026 at 11:22..
[𝘀𝗽𝗿] changes to main this commit is based on

Created using spr 1.3.6-beta.1

[skip ci]
https://invent.kde.org/qt/clang/llvm-project/-/commit/836904b855586881f2b72f23ed18c68656b9d728

Git commit 3a7c2d9f82331fbf0eb11408093b9f7696e664b4 by Pengcheng Wang on 18/08/2026 at 11:22..
[𝘀𝗽𝗿] initial version

Created using spr 1.3.6-beta.1
https://invent.kde.org/qt/clang/llvm-project/-/commit/3a7c2d9f82331fbf0eb11408093b9f7696e664b4

Git commit bd9c0ebb21b68580f5976ed4781883b0e46ee717 by Pengcheng Wang on 19/08/2026 at 10:23..
[𝘀𝗽𝗿] changes introduced through rebase

Created using spr 1.3.6-beta.1

[skip ci]
https://invent.kde.org/qt/clang/llvm-project/-/commit/bd9c0ebb21b68580f5976ed4781883b0e46ee717

Git commit 5ca6ab9719533dd82d732673ed055dbf5042c119 by Pengcheng Wang on 19/08/2026 at 10:23..
Match lowering and add more tests

Created using spr 1.3.6-beta.1
https://invent.kde.org/qt/clang/llvm-project/-/commit/5ca6ab9719533dd82d732673ed055dbf5042c119