[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/arsenm/amdgpu/reapply-clang/amdgpu-use-targetparser-targetid-handling'.
Changed from 0000000000000000000000000000000000000000 to f2dc9a474f7a5040fcdc0aab05dac945d451a7ec
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 73817e6a9279833e53fb9ccca3158ed987c4ad61 by GitHub (on behalf of Heejin Ahn) on 04/08/2026 at 05:19..
[WebAssembly] Add funclet bundle to thread local wrapper calls (#213826)

When accessing a thread local variable, Clang generates a thread local
wrapper function that checks if the variable has been initialized, and
if it isn't, initializes it. This is a function call, so if this is
within a funclet (i.e., within a `catchpad` or `cleanuppad`), it needs
the funclet bundle argument, which was missing before. If it lacks a
funclet argument, it will be considered invalid and removed in
WinEHPrepare.

Fixes https://github.com/emscripten-core/emscripten/issues/27448.
https://invent.kde.org/qt/clang/llvm-project/-/commit/73817e6a9279833e53fb9ccca3158ed987c4ad61

Git commit ecd6a18e03d37c2bcaf9893d9ae2698b66ac2e83 by GitHub (on behalf of Jianhui Li) on 04/08/2026 at 05:35..
[mlir][xegpu] Support batched matmul in    VectorToXeGPU ContractionLowering (#211947)

Generalizes ContractionLowering in
mlir/lib/Conversion/VectorToXeGPU/VectorToXeGPU.cpp so that (batched)
N-D vector.contract ops lower to xegpu.dpas, not just plain 2D matmuls.

---------

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

Git commit 8b18aa0b1ec2de76d47748a4d13c4de02b4d8580 by GitHub (on behalf of Garvit Gupta) on 04/08/2026 at 05:43..
[RISCV] Reduce spill/reload pairs when Xqcilo extension is enabled (#212807)

[RISCV] Reduce spill/reload pairs when Xqcilo extension is enabled

Currently, `SelectAddrRegImm26` calls `SelectAddrFrameIndex` first,
causing bare frame-index loads (offset 0) to select 48-bit loads/stores at
ISel. Due to `AddedComplexity=2` on the QC48LdPat patterns, the wide
opcode won over the standard LW/SW even though the resolved frame offset
typically fits simm12.

This led to more spills and reloads in functions which are under high
register pressure because 48-bit loads and stores are not marked easily
rematerializable. Also, simply adding 48-bit loads and stores to
`isLoadFromStackSlot/isStoreToStackSlot` doesn't solve the regression
for the multi call case and only by making Isel produce the plain
32/64-bit loads and store opcodes as the baseline does RA behave
identically.

Therefor this PR fixes the issue by:

-Remove the `SelectAddrFrameIndex` call from SelectAddrRegImm26. Bare frame
indices now fall through to standard LW/SW selection at ISel, where RA
recognizes them as rematerializable stack loads.

-Add post-RA promotion in `eliminateFrameIndex`: when a plain LW/SW has a
resolved frame offset that exceeds simm12, promote the opcode to
the corresponding 48-bit load/store opcode and fold the 26-bit offset
directly. This preserves the intended large-offset optimization
without affecting RA decisions.

This solves the code size regression in high register pressure function
introduced by PR #209315

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

Git commit 7bf32f63ee90b964a49212efd09ebd299d6718bb by GitHub (on behalf of Michael G. Kazakov) on 04/08/2026 at 05:58..
[libc++][pstl] Implementation of parallel std::reverse() based on parallel for_each (#213487)

This PR implements a parallel version of `std::reverse()` based on the
parallel `__for_each()`.

The implementation walks the first half of the range in chunks, each
chunk is swapped with its mirrored counterpart via `std::swap_ranges()`
and `std::reverse_iterator<>`:
```c++
// Perform a chunked for_each on the first half of the range.
return __cpu_traits<_Backend>::__for_each(
    first, first + (last - first) / 2, [first, last](ForwardIterator i, ForwardIterator j) {
    // Derive the last position of the mirrored range.
    ForwardIterator mirror_last = last - (i - first);
    // Swap the elements in the range of the first half with their mirrored counterparts in the second half.
    std::swap_ranges(i, j, std::reverse_iterator<ForwardIterator>(mirror_last));
});
```

Included tests check that:
- Semantics of the function is correct.
- The function correctly SFINAE out when the first argument is not an
execution policy.
- The `noexcept` policy is followed.
- `static_assert` verifies iterators' categories.

Part of #99938.
https://invent.kde.org/qt/clang/llvm-project/-/commit/7bf32f63ee90b964a49212efd09ebd299d6718bb

Git commit b8fd0c1cbb1867ddf74eb80ced58c5d289a56321 by GitHub (on behalf of Michael G. Kazakov) on 04/08/2026 at 06:00..
[libc++][pstl] Implementation of parallel std::is_sorted_until() based on std::adjacent_find() (#213445)

This PR adds implementation of a parallel `std::is_sorted_until()` based
on the parallel `std::adjacent_find()` and rebases the parallel
`std::is_sorted()` onto `std::is_sorted_until()`.

The implementation is effectively a one-liner:
```c++
// Find the first pair of adjacent elements that are not in sorted order,
// i.e. comp(rhs, lhs) is true.
auto res = AdjacentFind()(policy, std::move(first), last, [&](Ref lhs, Ref rhs) {
    return comp(rhs, lhs);
});
```

Included tests check that:
- Semantics of the iterator-only version is correct.
- Semantics of the predicated version is correct.
- The functions correctly SFINAE out when the first argument is not an
execution policy.
- The `noexcept` policy is followed.
- The `nodiscard` policy is followed.
- `static_assert` verifies iterators' categories.

Part of #99938.
https://invent.kde.org/qt/clang/llvm-project/-/commit/b8fd0c1cbb1867ddf74eb80ced58c5d289a56321

Git commit a2a70991059b04c8cfc8b4c3715361cf0024d6af by GitHub (on behalf of Matt Arsenault) on 04/08/2026 at 06:01..
AMDGPU: Validate generic processor features in TargetParser emitter (#213774)

Perform some initial validation that the feature set of generic
targets is consistent with the set of covered targets. For now, this
only performs this validation for the subset of frontend exported
features, so is limited to catching missed builtin support. In the future
arbitrary features should be validated, but this is complicated by workaround 
features and size features which need to clamp to the common minimum.

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

Git commit f2dc9a474f7a5040fcdc0aab05dac945d451a7ec by Matt Arsenault on 04/08/2026 at 06:07..
Reapply "clang: Use TargetID parsing from AMDGPUTargetParser" (#213824)

This reverts commit 8f82ba2c79f4e6a69a884cc9e19bd0b8c0bbe932.
https://invent.kde.org/qt/clang/llvm-project/-/commit/f2dc9a474f7a5040fcdc0aab05dac945d451a7ec