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

Git repository change summary for qt/clang/llvm
Pushed by mirror-service into branch 'upstream/main'.
Changed from 2877672c1331f9a99f645a0ad25801380da42dcd to b97d8b20b7ba2f3bb18a12974f1e97c7ec158ac3
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 4d10131304d90d997868f2417b086ad1cd116ebc by GitHub (on behalf of Fangrui Song) on 10/08/2026 at 05:34..
[BFI] Index iterative inference by block number (#215179)

`applyIterativeInference` builds a DenseMap assigning each participating
block a position in a dense vector. Block numbers already provide that
index, and BFI uses them elsewhere.
https://invent.kde.org/qt/clang/llvm/-/commit/4d10131304d90d997868f2417b086ad1cd116ebc

Git commit 52d63830c519ed2d51c43fc418f0ae3232ac65e9 by GitHub (on behalf of Fangrui Song) on 10/08/2026 at 05:49..
[Support] Optimize ScaledNumbers::multiply64 (#215172)

The 128-bit product is assembled from four 32x32 cross products.
(4 imul on x86-64). Use `__uint128_t` where available.
https://invent.kde.org/qt/clang/llvm/-/commit/52d63830c519ed2d51c43fc418f0ae3232ac65e9

Git commit a4f740f144ddccb30bd3b26c69740914518a642b by GitHub (on behalf of Bagodiya) on 10/08/2026 at 06:17..
[InstCombine] Fold X + ((-X) & (C - 1)) to (X + C - 1) & -C (#215122)

`X + ((-X) & (C - 1)) --> (X + C - 1) & -C` for power-of-two `C`.

This is the align-up idiom as allocators usually write it. `-C == ~(C -
1)`, so
the mask is just the inverted low-bit mask.
No wrapping flags needed - it verifies without nsw/nuw on either side.
Flags on
the original add are dropped.

The other fold in the issue, `X + (X | -X) --> X & (X - 1)`, already
exists in
visitAdd, so this only adds the second one.

One case that doesn't hit this: `C = 2`. InstCombine turns `(-X) & 1`
into
`X & 1` first, so the neg is already gone.

 https://alive2.llvm.org/ce/z/sCCJzq
C = 2: https://alive2.llvm.org/ce/z/xeQqkz

Fixes #214675
https://invent.kde.org/qt/clang/llvm/-/commit/a4f740f144ddccb30bd3b26c69740914518a642b

Git commit 3eb121cd9f7d2069493b19f83434570caad11e70 by GitHub (on behalf of Bryth) on 10/08/2026 at 06:18..
[mlir][complex] Make AddOp commutative (#212199)

Complex AddOp should have the `Commutative` trait to follow Arith's
AddOp semantics.
https://invent.kde.org/qt/clang/llvm/-/commit/3eb121cd9f7d2069493b19f83434570caad11e70

Git commit 93c0911a74433395155ceee38dfe8842f0fc639d by GitHub (on behalf of Bryth) on 10/08/2026 at 06:19..
[mlir][complex] Fix signed zero miscompile with complex.add fold (#212751)

The pattern `a + complex.constant<0.0, 0.0>` currently gets folded to
`a`. This is incorrect when e.g. `a=(-0.0, 1.0)` since as per the IEEE
spec and what's done in the arith dialect `0.0 + (-0.0) = 0.0 !=
(-0.0)`.

This PR changes the pattern to `a + complex<-0.0, -0.0> -> a` and
updates the associated test.
https://invent.kde.org/qt/clang/llvm/-/commit/93c0911a74433395155ceee38dfe8842f0fc639d

Git commit 129267e8fcfca0bc68509817f944eea6b6910ac5 by GitHub (on behalf of Kaviya Rajendiran) on 10/08/2026 at 06:40..
[Flang][OpenMP] Add nsw flags to OMPIRBuilder loop IV arithmetic (#214165)

- Extended the support of `-fno-wrapv` flag setting from frontend to the
OMPIRBuilder via `omp.integer_wrap_around` module attribute.
- When this attribute `omp.integer_wrap_around` is false (-fno-wrapv),
the OMPIRBuilder attaches `nsw` to all loop IV arithmetic.
- This enables SCEV to form proper `AddRec` expressions for the loop IV,
allowing `IndVarSimplify pass` to widen it from i32 to i64 and eliminate
the in-loop sext instruction which helps some backend optimizations and
also producing IR similar to Clang.

Fixes https://github.com/llvm/llvm-project/issues/213718
https://invent.kde.org/qt/clang/llvm/-/commit/129267e8fcfca0bc68509817f944eea6b6910ac5

Git commit b595a746983b828c40140df53fe01eb76c6044f4 by GitHub (on behalf of MiaoMing Chen) on 10/08/2026 at 06:49..
[clang][ASTMatchers] Fix `hasArraySize` crash without a size expression (#215082)

CXXNewExpr::getArraySize() returns std::nullopt even when isArray() is
true, e.g. when there is no array size expression, as in 'new int[]()'.
The hasArraySize matcher dereferenced the optional unconditionally,
triggering undefined behavior (an assertion failure in assert-enabled
builds). Check the optional for engagement before matching.

Since getArraySize() already returns std::nullopt when isArray() is
false, the redundant isArray() check can be dropped.

Add a clang-tidy regression test that runs clang-tidy on a translation
unit containing 'new int[]()', which emits a compiler diagnostic but
must not crash the tool, and document the fix in the release notes.

Fixes #214281
https://invent.kde.org/qt/clang/llvm/-/commit/b595a746983b828c40140df53fe01eb76c6044f4

Git commit 1f85e810c9ae0e8f9f44a7373c5409d8e586ed06 by GitHub (on behalf of Pranav Kant) on 10/08/2026 at 06:51..
[LoopInfo] Do not enqueue unreachable nodes; fix infinite loop (#214832)

Before this patch, we were enqueing unreachable nodes reaching into the
latch nodes. Since unreachable nodes haven't been visited in the
original DFS algorithm, we end up in an infinite loop within enqueue

This patch restores isReachableFromEntry() check from now removed
discoverAndMapSubloop(). This should avoid infinite loop.

It's a regression from #212000
(5d582e4003b1cab59900d16fa3db9c3a9d16b462)

---------

Co-authored-by: Alexander Kornienko <[email protected]>
Co-authored-by: Alexis Engelke <[email protected]>
https://invent.kde.org/qt/clang/llvm/-/commit/1f85e810c9ae0e8f9f44a7373c5409d8e586ed06

Git commit 0f985af790f8d542b126de8c3d219fc591df9652 by GitHub (on behalf of William Tran-Viet) on 10/08/2026 at 06:53..
[libc++] Refactor `optional<T>` and `optional<T&>` base classes (#215012)

- Remove the shared `__optional_storage_base` base class and associated
partial specializations to handle the `T&` case in `optional<T>`
- As a consequence, the `static_assert`s that check for reference types
in `optional<T>` need to be moved up to the base class as the
`is_object_v` check is tripped, otherwise.
- Directly inline base class functions for both that used to exist to
accommodate a "dual-mode" (`T` and `T&`) `optional`.
https://invent.kde.org/qt/clang/llvm/-/commit/0f985af790f8d542b126de8c3d219fc591df9652

Git commit 98d5b27f79fc897cfc8b72a91a20890fb7443156 by GitHub (on behalf of LU-JOHN) on 10/08/2026 at 06:58..
[AMDGPU] Fold constants in 2-elt vector canonicalization (#214384)

For 2-element vectors convert:

`fcanonicalize (build_vector x, k)` -> `build_vector (fcanonicalize x),
(fcanonicalize k)`
`fcanonicalize (build_vector x, undef)` -> `build_vector (fcanonicalize
x), 0`

if fcanonicalize is Legal for a single element.  

Previously only v2f16 was transformed. Now v2f32 and v2f64 are also
transformed, but v2f16 is naturally excluded.

---------

Signed-off-by: John Lu <[email protected]>
https://invent.kde.org/qt/clang/llvm/-/commit/98d5b27f79fc897cfc8b72a91a20890fb7443156

Git commit df555425e7023fb1783525a6feee57f82d82b0fb by GitHub (on behalf of Hristo Hristov) on 10/08/2026 at 07:06..
[libc++][memory] LWG4148: `unique_ptr::operator*` should not allow dangling references (#214971)

Implements https://wg21.link/LWG4148

Closes #118362

---------

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

Git commit 54d02da71ecee5569e515a43dc9e5429917078f6 by GitHub (on behalf of Chuanqi Xu) on 10/08/2026 at 07:26..
[C++20] [Modules] Don't set clang module as named module for module duplication check (#215184)

Close https://github.com/llvm/llvm-project/issues/204632

Note that the error message is already diagnosed. So we don't need to do
additional thing here.
https://invent.kde.org/qt/clang/llvm/-/commit/54d02da71ecee5569e515a43dc9e5429917078f6

Git commit 2b2bf30c00ae068c1edf3c7753c8c14157207f64 by GitHub (on behalf of SunilKuravinakop) on 10/08/2026 at 07:32..
[flang][OpenMP] Support for compare fail (#214179)

Support for fail clause in "!omp atomic compare fail".
  
This also Fixes
[#214176](https://github.com/llvm/llvm-project/issues/214176)

Co-authored-by: Sunil Kuravinakop
https://invent.kde.org/qt/clang/llvm/-/commit/2b2bf30c00ae068c1edf3c7753c8c14157207f64

Git commit 8ea1b9dc4dbea13e0c093389399a28b9b35bb629 by GitHub (on behalf of Lang Hames) on 10/08/2026 at 07:42..
[ORC] Generalize rt::Proxy result mapping to Error / Expected<T> callees (#215181)

Previously a Proxy's callee return type RetT mapped to the client-facing
result (ErrorRetT) as: void -> Error, everything else -> Expected<RetT>.
That could not represent a callee whose own result is fallible: an
Error-returning callee became Expected<Error>, and an Expected<T> callee
became Expected<Expected<T>>.

Generalize the mapping to:
  void        -> Error
  Error       -> Error
  T           -> Expected<T>
  Expected<T> -> Expected<T>   (flattened, not nested)

so a dispatch failure and the callee's own error collapse into a single
Error/Expected<T>. The SPS ProxySpec dispatch handles the new cases,
forwarding an Error/Expected callee's own result and, on a dispatch
failure, discarding the (unproduced) placeholder result before reporting
the error.

This is a pure generalization in support of upcoming work that needs to
proxy APIs returning Error or Expected<T>.

Adds ProxyTest and SPSProxiesTest coverage for the Error and Expected<T>
cases, plus static_asserts pinning the type mapping.
https://invent.kde.org/qt/clang/llvm/-/commit/8ea1b9dc4dbea13e0c093389399a28b9b35bb629

Git commit 82825dd420c562d5dab1ef884f5d0b8c10eab7a5 by GitHub (on behalf of Folkert de Vries) on 10/08/2026 at 08:43..
[MIPS] fix zero-sized type  causing incorrect register for later float arguments (#213746)

fixes https://github.com/llvm/llvm-project/issues/213540

https://godbolt.org/z/zMW6MMoze

On O32 a zero-sized type is not passed, but it does (in GCC) end the run
of leading float arguments that are passed in float registers. The new
behavior is consistent with GCC. It seems unlikely that people rely on
this (zero-sized structs are rare in C, but much more common in Rust) so
I did not bother with the ABI flag. It could be added though if there is
reason to.
https://invent.kde.org/qt/clang/llvm/-/commit/82825dd420c562d5dab1ef884f5d0b8c10eab7a5

Git commit 57227c70be689b1d81354adadcc01bb292da939a by GitHub (on behalf of Dhairyashil R G) on 10/08/2026 at 08:49..
[mlir][vector] Don't fold in_bounds for scalable vector dimensions (#213506)

`isInBounds` compares `index + getVectorType().getDimSize(resultIdx)`
against the static size of the corresponding source dimension. For a
scalable dimension the vector holds `vscale * getDimSize(resultIdx)`
elements, so the static size is only a lower bound and the comparison
can succeed for a transfer that is actually out of bounds.

For example, reading `vector<[4]xf32>` at index 0 of a `memref<4xf32>`
folds to `in_bounds = [true]` because `0 + 4 <= 4`. Lowering then turns
a predicated masked load into a plain full-width load:

```mlir
// Without the fold: predicated, lanes >= 4 are inactive.
%8  = llvm.intr.stepvector : vector<[4]xi32>
%16 = llvm.icmp "slt" %8, %15 : vector<[4]xi32>
%23 = llvm.intr.masked.load %22, %16, %20 {alignment = 4 : i32} :
        (!llvm.ptr, vector<[4]xi1>, vector<[4]xf32>) -> vector<[4]xf32>

// With the fold: unpredicated, reads `4 * vscale` elements.
%9  = llvm.load %8 {alignment = 4 : i64} : !llvm.ptr -> vector<[4]xf32>
```

which reaches AArch64 as `ld1w { z1.s }, p1/z, [x1]` and `ldr z1, [x1]`
respectively. For every `vscale > 1` the folded form reads past the end
of the allocation. The same applies to `vector.transfer_write`, where
the fold turns a masked store into an out-of-bounds one.

Bail out for scalable result dimensions. Fixed-size dimensions of a
partly scalable vector are unaffected and still fold; the added
`vector<4x[4]xf32>` test covers that.

Confirmed on SVE hardware (AWS Graviton3, 256-bit vectors, vscale = 2)
with the 4-element buffer placed flush against a PROT_NONE guard page:

  predicated   ld1w -> returns 10.0, exit 0
  unpredicated ldr  -> SIGSEGV, exit 139

Assisted-by: Claude
https://invent.kde.org/qt/clang/llvm/-/commit/57227c70be689b1d81354adadcc01bb292da939a

Git commit f1890ba90f6fbe42d6d0dd13fe4129f66292ccfb by GitHub (on behalf of David Spickett) on 10/08/2026 at 09:19..
[lldb][AArch64] Use unique_ptr instead of statics in RegisterTypeDetector (#214515)

Fixes #214264.

I used static variables for the created types, on the assumption
that only one detector would be used and that the host's
features would not change.

That is true for an lldb-server on a real Linux/FreeBSD system.
It is not true when we use the detector with core files. In the
same LLDB session you might load several files that came from
systems with different features.

The result was that the first detection sets up the static variables
and future detections do not update them. So subsequent core
files can have incorrect types.

(and in future if types vary per-process, we could have the same
issue in lldb-server)

To address this I am changing where the types are stored so that
each instance of the detector has its own set of types for which
it manages the lifetime.

* There is a vector of unique pointers to types. This vector
  is a member, so is per instance of the detector class.
* As new types are added to this vector, it may reallocate,
  but the location of the RegisterTypes themselves will stay
  the same, this is important.
* Detector functions use MakeType to create types, and MakeType
  handles managing the vector. Nothing else accesses the vector
  directly.
* MakeType returns a raw pointer to the type.
* Detector functions return a raw pointer to the top level
  type for the register. For example if it has flags that
  have enums for their fields, the flags type is the top level
  type.
* These top level raw pointers are given to the rest of LLDB.
* We assume that the lifetime of the dector is > that of anyone
  using the raw pointers.
* When the detector destructs, the unique pointers destruct and
  the RegisterTypes are freed.

This handing out of raw pointers is likely a bad idea, but I
want to keep the changes here within the detector.

All existing tests pass, and I have added a test that loads 2
core files with different features. That test fails without
these changes because the STORE_ONLY feature is detected
incorrectly.
https://invent.kde.org/qt/clang/llvm/-/commit/f1890ba90f6fbe42d6d0dd13fe4129f66292ccfb

Git commit b22c8a65c266ad3b3aac1a9344d2a5b01e946ded by GitHub (on behalf of Florian Hahn) on 10/08/2026 at 09:23..
[ConstraintElimination] Defer removal of simplified ssub.with.overflow (#215135)

replaceSubOverflowUses erased the intrinsic as soon as it became dead.
That frees the intrinsic's operand Use array, but the worklist can still
hold UseCheck entries pointing into it, storing a now invalid pointer to
a Use *.

Instead of erasing the intrinsic in place, poison its arguments and push
it onto ToRemove.

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

Git commit 75a45c373407c13a44c7abb28a78d891a97fe665 by GitHub (on behalf of Andrzej Warzyński) on 10/08/2026 at 09:35..
Revert "[mlir][vector] Verify non-unit strides on `masked/expand/compress` ops  (#210952)" (#215224)

This reverts commit ac646b5be0d7764a1dbeb86e4f8d54df2d4fd3eb.

The following integration tests are failing:
  * Integration/Dialect/Linalg/CPU/ArmSME/matmul.mlir
  * Integration/Dialect/Linalg/CPU/ArmSME/multi-tile-matmul-mixed-types.mlir

Failing bot:
  * https://lab.llvm.org/buildbot/#/builders/121/builds/2588
https://invent.kde.org/qt/clang/llvm/-/commit/75a45c373407c13a44c7abb28a78d891a97fe665

Git commit 3736fe2d622bb26ffe2acf80639faa35b4108c79 by GitHub (on behalf of Zeyi Xu) on 10/08/2026 at 09:43..
[clang-tidy] Remove deprecated zircon module (#215063)

Follow up of https://github.com/llvm/llvm-project/pull/162012
https://invent.kde.org/qt/clang/llvm/-/commit/3736fe2d622bb26ffe2acf80639faa35b4108c79

Git commit 4eda802f237735adbc239791853aba4b11c2fb37 by GitHub (on behalf of David Spickett) on 10/08/2026 at 10:02..
[lldb][AArch64] Remove size from type detector entries (#214733)

This was passed to the constructor but goes unused.
The detector functions know the size of the type
they're creating already.
https://invent.kde.org/qt/clang/llvm/-/commit/4eda802f237735adbc239791853aba4b11c2fb37

Git commit 89a2137aa09ec1bb4832628e0fa54adb5831fb0b by GitHub (on behalf of Nikolas Klauser) on 10/08/2026 at 10:04..
[libc++] Remove _IsThisTuple (#213909)

We can inline it into `_EnableUTypesCtor` instead.
https://invent.kde.org/qt/clang/llvm/-/commit/89a2137aa09ec1bb4832628e0fa54adb5831fb0b

Git commit df90dfb7a2652b85e121b94578a6195b9a74e93f by GitHub (on behalf of Dharuni R Acharya) on 10/08/2026 at 10:06..
[NVPTX] Add intrinsics for ue5m3x2 to f16x2/bf16x2 conversions (#214411)

This patch adds the following intrinsics for `ue5m3x2` to `f16x2/bf16x2`
conversions introduced in PTX 9.4:

- `cvt.rn.f16x2.ue5m3x2`
- `cvt.rn{.satfinite}{.scaled::n2::ue8m0}.bf16x2.ue5m3x2`

Tests have been verified through `ptxas-13.4`.
---------

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

Git commit 364002a941d75f281556657cb4529e8265a272aa by GitHub (on behalf of Ramkumar Ramachandra) on 10/08/2026 at 10:13..
[LoopSplitUtils] Revert, removing from tree (#214577)

This reverts commits:

- 2354dce21 ([Transforms][Utils] Add LoopSplitUtils for iteration-space
loop splitting, #205995)
- 8f1efc26 ([Transforms][Utils] Preserve branch weights in
LoopSplitUtils, #213626)
- 49ace5ab ([Transforms][Utils] Test for branch weight preservation in
LoopSplitUtils, #213647)

Removing LoopSplitUtils from the tree completely, as several crashes
were uncovered after it was added. A highly reduced initial version with
much better test coverage is proposed for the re-land.
https://invent.kde.org/qt/clang/llvm/-/commit/364002a941d75f281556657cb4529e8265a272aa

Git commit 47f32bddd3496cea2eac0df5f46108a704dde51d by GitHub (on behalf of Jinpeng Wang) on 10/08/2026 at 10:20..
[VectorCombine] Fold reduction chains with equivalent bitcast sources (#212084)

## Description

`foldShuffleChainsToReduce` currently identifies leaf sources by SSA
value identity.
This can prevent a shuffle reduction chain from being folded when
multiple bitcast instructions represent the same vector source.

This happens when an earlier VectorCombine transform moves a bitcast
through a shuffle and creates a new bitcast of the same underlying
value.
The reduction matcher then sees the original and newly created bitcasts
as separate sources and rejects the fold.

This PR treats bitcast sources as equivalent when they have the same
result type and the same operand.
It then merges the demanded lanes of equivalent sources while preserving
duplicate-lane semantics:

* Reject duplicate or overlapping lanes for non-idempotent reductions.
* Allow overlapping lanes for idempotent reductions.
* Continue to reject sources with different underlying values or result
types.

This allows the default optimization pipeline to recognize and fold the
horizontal reductions in both `hsum_i32_4` and `hsum_i32_8` in #210897

## Tests

* Add VectorCombine tests for:
  * equivalent bitcast sources with disjoint demanded lanes;
  * overlapping lanes for non-idempotent reductions;
  * duplicates within a later equivalent source;
  * bitcasts of different underlying values;
  * overlapping lanes for idempotent reductions.

Fixes #210897.
https://invent.kde.org/qt/clang/llvm/-/commit/47f32bddd3496cea2eac0df5f46108a704dde51d

Git commit 29726d8824c206f3b633f526241df2fc3e68b5b6 by GitHub (on behalf of David Spickett) on 10/08/2026 at 10:22..
[lldb][AArch64] Detect type for many registers with a single function (#214734)

It was pointed out during review of
https://github.com/llvm/llvm-project/pull/214515
that the type for the 2 GCS registers will be created twice.
Each one will have the same ID so we will only emit one and
the other goes unused.

To account for this, and the possibility of not just 2 but N
registers later, I've changed the name in the register entry
to a list of names.

So for the 2 GCS registers we only do detection once, and both
of them will refer to the same instance of the type.
https://invent.kde.org/qt/clang/llvm/-/commit/29726d8824c206f3b633f526241df2fc3e68b5b6

Git commit a7fd911d28814406982bc91adba8427484660496 by GitHub (on behalf of Philipp Rados) on 10/08/2026 at 10:25..
[RISCV] Change undef->poison in cttz_elts.ll test (#215218)

Since `undef` is deprecated and triggers CI-failures when changing
existing tests. Discussed in
https://github.com/llvm/llvm-project/pull/214795#discussion_r3747841496
https://invent.kde.org/qt/clang/llvm/-/commit/a7fd911d28814406982bc91adba8427484660496

Git commit b4c970ca4db13275e3c52c16d0d2c1eaf5777337 by GitHub (on behalf of Simon Pilgrim) on 10/08/2026 at 10:33..
[X86] Add pdep/pext vector test coverage (#215231)

Baseline tests for #214508
https://invent.kde.org/qt/clang/llvm/-/commit/b4c970ca4db13275e3c52c16d0d2c1eaf5777337

Git commit d928627261fac01fb32ec4f0cdabe7e838e09a34 by GitHub (on behalf of Florian Hahn) on 10/08/2026 at 10:40..
[VPlan] Cost truncated widened inductions via ::computeCost. (#212786)

Follow-up to https://github.com/llvm/llvm-project/pull/202232 to also
compute costs for truncated inductions in ::computeCost, removing the
fallback to the legacy cost model unless the loop is fully unrolled.

Note that this changes vectorization decisions in both direction, e.g.
* now vectorized `@tail_predicate_without_optsize`: legacy costs <16 x
i64>, whereas we generate a narrow IV <16 x i8>, which is much cheaper
* no longer vectorized `@second_lshr_operand_zero_via_scev()`: we
generate 2 IVs (one truncated and one not truncated), which is more
expensive than the single IV LV assumes (note that previously we would
ignore the cost of the trunc in the cost computation, because the trunc
was replaced by the wide truncated IV, which was assumed free.

Both cases are due to more accurate cost computations.

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

Git commit c6a18ac34dc73ac9e2cdddf28a64860ef24d706b by GitHub (on behalf of Zhiheng Xie) on 10/08/2026 at 10:54..
[AArch64] Add initial sched model for hip12 (#212935)

This patch adds initial sched model for Hisilicon's hip12 core (Kunpeng
950 processor).
https://invent.kde.org/qt/clang/llvm/-/commit/c6a18ac34dc73ac9e2cdddf28a64860ef24d706b

Git commit 3027f328459a95bf87abd26f72024c59490023bd by GitHub (on behalf of Ramkumar Ramachandra) on 10/08/2026 at 11:01..
[LV] Avoid adding stray predicates in isConsecutivePtr (#213662)

If the absolute value of Stride is not unit, avoid adding stray SCEV
predicates.
https://invent.kde.org/qt/clang/llvm/-/commit/3027f328459a95bf87abd26f72024c59490023bd

Git commit 794aa0fd923acc744f7086d2c77a336dcca6256d by GitHub (on behalf of 曾鈜寬 Tseng Hung Kuan) on 10/08/2026 at 11:09..
[APFloat] Don't turn a Float8E8M0FNU NaN into an Inf on conversion (#214919)

`Float8E8M0FNU` has a precision of 1, so it stores no significand bits
and its NaN carries no payload. `IEEEFloat::convert` shifts the (empty)
significand into the target format, which leaves the NaN exponent with
an all-zero significand — and that is the encoding of an infinity in any
format that has infinities.

The `APFloat` object still reports `fcNaN`, so `isNaN()` returns true,
but `bitcastToAPInt()` hands back Inf bits. Anything that stores the bit
pattern rather than the object — `ConstantFP`, MLIR's `FloatAttr` —
therefore ends up with an infinity.

In MLIR this shows up when folding `arith.extf` on an `f8E8M0FNU`
constant. The OCP MXFP spec uses the all-ones encoding as the scale of
an invalid block, so this silently replaces "this block is invalid" with
a value that poisons everything it is multiplied into:

```mlir
func.func @e8m0_nan_to_f32() -> f32 {
  %c = arith.constant 0xFF : f8E8M0FNU
  %0 = arith.extf %c : f8E8M0FNU to f32
  return %0 : f32
}
```

```
$ mlir-opt x.mlir -canonicalize
%cst = arith.constant 0x7F800000 : f32     // +Inf, not a NaN
```

f16 gives `0x7C00`, bf16 `0x7F80` and f64 `0x7FF0000000000000` — all Inf
encodings. `convert` reports `opOK` with `losesInfo == false` in every
case.

`Float8E8M0FNU` is the only semantics in the table with `precision ==
1`, so this is the only source format affected. The fix creates a new
NaN in the target semantics when the source has no significand, next to
the existing fix-up for `fltNanEncoding::NegativeZero` sources, which
handles the analogous NaN-to-`-Inf` case.

Verification: exhaustively over all 256 `Float8E8M0FNU` values against
f16, bf16, f32, f64 and f128, checking that the category survives, that
a NaN never comes out as an Inf, that the stored bit pattern read back
through the target semantics is still a NaN, and that finite scales
round-trip unchanged where the target's exponent range allows it.
Reverting the `APFloat.cpp` hunk makes the new unit test fail.
https://invent.kde.org/qt/clang/llvm/-/commit/794aa0fd923acc744f7086d2c77a336dcca6256d

Git commit b97d8b20b7ba2f3bb18a12974f1e97c7ec158ac3 by GitHub (on behalf of Ankit Kumar Tiwari) on 10/08/2026 at 11:10..
[LoopVectorize][X86] Improve libmvec SSE/AVX/AVX-512 test coverage (#211863)

This PR updates the libmvec loop vectorization tests to use `-force-vector-width` instead of hardcoded loop metadata.

Fixes #211532
https://invent.kde.org/qt/clang/llvm/-/commit/b97d8b20b7ba2f3bb18a12974f1e97c7ec158ac3