[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/release/23.x'.
Changed from 83cbf70cb201f58cb174039d7c3792bba6d3f95a to 165c472d65cd62eb332246eb39901603e4b1e4ce
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 a36edf659ef8e168a3e1196cfb7df77522a12b36 by Douglas Yung (on behalf of aokblast) on 22/07/2026 at 13:42..
[Clang][Interpreter] Don't pass -fPIC on MSVC (#210507)

(cherry picked from commit 617e4f54e503b54b08445a086d95a80aa72a58d0)
https://invent.kde.org/qt/clang/llvm-project/-/commit/a36edf659ef8e168a3e1196cfb7df77522a12b36

Git commit 2cff4ff7a21c91b3493eb0fd8a7f072aee77fe7d by Douglas Yung (on behalf of Eli Friedman) on 22/07/2026 at 13:43..
Make ios_base::xalloc non-atomic with LIBCXX_ENABLE_THREADS=OFF. (#208356)

762b77a moved the definition of "xindex" out of the header, and in the
process dropped the _LIBCPP_HAS_THREADS check. Re-add the check to
maintain the status quo.

The discussion on https://github.com/llvm/llvm-project/pull/198994
indicates it's not clear whether LIBCXX_ENABLE_THREADS=OFF is actually
supposed to mean single-threaded. But it clearly does in practice:
atomic_support.h uses non-atomic ops when threads are disabled, and a
few other APIs have explicit non-atomic fallback paths.

My team ran into this trying to run libc++ tests for a RISC-V core
without the "a" extension.

(cherry picked from commit 3eb929be5e17d66900020bd1caa7d2510d4f9601)
https://invent.kde.org/qt/clang/llvm-project/-/commit/2cff4ff7a21c91b3493eb0fd8a7f072aee77fe7d

Git commit 5deccad3415aacaec099795cd1d57dfd84b767e0 by Douglas Yung (on behalf of Younan Zhang) on 22/07/2026 at 13:44..
[Clang] Ensure correct template parameter depth for abbreviated templates (#209693)

This fixes another case of member functions where we overlooked template
depths when only abbreviated template parameters are involved.

This mirrors previous fix cfb25203c25f, but I don't intend to put it in
ParseTrailingRequiresClause because we might want the similar fix for
e.g. noexcept expressions, so let's keep it inline for future refactor.

The example comes from #205557.

(cherry picked from commit 3485d8591992a967553493c53f17d9f3e8a0fc8e)
https://invent.kde.org/qt/clang/llvm-project/-/commit/5deccad3415aacaec099795cd1d57dfd84b767e0

Git commit 71ee1456b23270f768571db9a4b060fc4f4b8569 by Douglas Yung (on behalf of Daniel Paoliello) on 22/07/2026 at 13:45..
[clang][win] Fix __global_delete wrappers for Arm64EC and cross-TU ::delete (#209585)

PR #188372 made Clang's MSVC-ABI deleting-destructor path route global
deletes
through compiler-generated __global_delete / __global_array_delete
wrappers
instead of referencing ::operator delete directly. This lets a deleting
destructor be emitted in environments (e.g. kernel mode) where no global
::operator delete exists: each wrapper defaults to a trapping
__empty_global_delete fallback, and a real forwarding body that calls
::operator delete is materialized only when the program actually uses
::delete.

This change refines how those wrappers and their fallbacks are emitted,
fixing
two problems that made the #188372 mechanism fail in practice.

New behavior:

- The trapping fallback is now emitted as a weak GlobalAlias to
__empty_global_delete rather than via an /alternatename directive. This
lowers
to a COFF weak-external-with-default -- exactly what MSVC emits -- so a
real
__global_delete defined in any TU overrides the fallback in every other
TU at
  link time.

- A ::delete expression now registers the wrapper for its resolved
global
operator delete directly (in EmitCXXDeleteExpr), so the strong
forwarding body
is emitted in that TU regardless of where the class's deleting
destructor is
defined. This matches MSVC, which emits the forwarder at every ::delete
site.

Bugs fixed:

1. Arm64EC (miscompile -> LNK2019). /alternatename only names the plain
symbol,
not the backend-generated "$$h" hybrid EC symbol referenced by the exit
thunk, so Arm64EC images left __global_delete$exit_thunk unresolved. The
weak
GlobalAlias correctly produces the "$$h" symbol, exit thunk, and plain
alias
   (verified on both x64 and Arm64EC).

2. Cross-TU ::delete (runtime crash). Previously the forwarding body was
only
emitted in a TU that *both* emitted a matching vector deleting
destructor and
contained a ::delete. A TU that only performed `::delete p` -- with the
class
defined elsewhere -- emitted no forwarder, so nothing overrode the
weak-alias
trap and the program executed a trapping __empty_global_delete at
runtime
(STATUS_ILLEGAL_INSTRUCTION). Registering the wrapper at the ::delete
site
   fixes this.

To share wrapper-creation logic between the deleting-destructor path and
the
delete-expression path, getOrCreateMSVCGlobalDeleteWrapper is promoted
from a
static helper in CGClass.cpp to a CodeGenModule method.

Verified end-to-end: a weak alias in one TU and a strong forwarder in
another
resolve to the forwarder under both lld-link and MSVC link.exe, and the
previously-crashing delete-only TU now runs cleanly.
https://invent.kde.org/qt/clang/llvm-project/-/commit/71ee1456b23270f768571db9a4b060fc4f4b8569

Git commit 9e6077709b2cb1ccc7dfde33112246b591920c6a by Douglas Yung (on behalf of David Green) on 22/07/2026 at 13:46..
[AArch64] Lower fixed width bf16 fpround (#209411)

Similar to #209194, this was previously hitting an error with an illegal
FP_ROUND_MERGE_PASSTHRU. This time we lower the fptrunc to a scalable
fptrunc and let it legalize naturally. On SVE systems a f64->bf16
fptrunc will fail to legalize, but lowers successfully with sve2 with
fcvtn. A store(fptrunc) -> truncstore combine was disabled too as it
fails with bf16.

(cherry picked from commit 50f2b9443d23eba757c3c0f42eef71e0f9721b15)
https://invent.kde.org/qt/clang/llvm-project/-/commit/9e6077709b2cb1ccc7dfde33112246b591920c6a

Git commit feb77ff81325db33229a17633e440af1adae5bb5 by Douglas Yung (on behalf of Jacek Caban) on 22/07/2026 at 13:47..
[CodeGen][ARM64EC] Copy first four arguments to FP registers in vararg exit thunks (#209581)

ARM64EC vararg functions receive all types of the first four arguments
in x0-x3. Because x86_64 expects floating-point arguments in FP
registers, always copy x0-x3 to d0-d3 in the exit thunks, matching
MSVC's behavior.

(cherry picked from commit 9c6a9f5fa37ffc21d4561301772bc600bd344d4c)
https://invent.kde.org/qt/clang/llvm-project/-/commit/feb77ff81325db33229a17633e440af1adae5bb5

Git commit 521b0ff9a6a85409f55264d92d838044c4e3b814 by Douglas Yung (on behalf of Petr Hosek) on 22/07/2026 at 13:48..
[libc++] Partially revert #208330 (#209928)

We found out that the new mechanism for detecting overriden functions
does not support Arm Pointer Authentication (PAuth). Addressing this
limitation is going to require changes to Clang. In the meantime, we
switched back to the old mechanism when PAuth is enabled.

(cherry picked from commit db7356dde8312a86e79ec0d7b7f844878a1a743c)
https://invent.kde.org/qt/clang/llvm-project/-/commit/521b0ff9a6a85409f55264d92d838044c4e3b814

Git commit 201044ab8851f22a15d1654b7d3a7d738c118e27 by Douglas Yung (on behalf of Jacek Caban) on 22/07/2026 at 13:49..
[LLD] [COFF] Fix linking directly against an ARM64X DLL without import library (#210311)

In mingw mode, when linking against a DLL, the user can either provide a
regular import library, or provide the actual DLL. When linking against
an ARM64X image, add both native and EC views to the symbol table on EC
targets. Also getMachine() on such images returns ARM64X, treat it as
ARM64 instead.

(cherry picked from commit 30f270edb42c5d37e4c4a413ebfc7a6513565b30)
https://invent.kde.org/qt/clang/llvm-project/-/commit/201044ab8851f22a15d1654b7d3a7d738c118e27

Git commit 9a93aaef36ded17830dd27905f2e61dbe322d33c by Douglas Yung (on behalf of Tony Guillot) on 22/07/2026 at 13:51..
[Clang] Fixed auto parsing regression with brace initialization (#210347)

The PR #208552 has introduced a regression where brace initialization
was not taken into account `auto foo{12}`. It was also breaking
`dcl.type.general` p2 rules, which is also now tested.

(cherry picked from commit d592aa5a10f44164cd403257270802eb2a4b123a)
https://invent.kde.org/qt/clang/llvm-project/-/commit/9a93aaef36ded17830dd27905f2e61dbe322d33c

Git commit a82f94b8f46766504a4f7ee0e9ddb65ebb6cf472 by Douglas Yung (on behalf of Patryk Stefanski) on 22/07/2026 at 13:51..
[clang][sema] Fix crash on decomposition decl missing initializer (#210151)

ActOnUninitializedDecl dereferenced the std::optional<Token> from
Lexer::findNextToken() unconditionally when diagnosing a structured
binding with no initializer. Guard the optional and fall back to the
declaration's location.

(cherry picked from commit 0e3852f73ab75639b76bad2c8a735d46241768f3)
https://invent.kde.org/qt/clang/llvm-project/-/commit/a82f94b8f46766504a4f7ee0e9ddb65ebb6cf472

Git commit 2ca1deea15528c1213c8a534b1a21053c33b8371 by Douglas Yung (on behalf of Logan) on 22/07/2026 at 13:52..
X86: Add pattern for optimized BLSIC IR form (#209814)

Add DAG pattern to recognize the optimized IR form of BLSIC: (xor (and
x, -x), -1)

Fixes #209718 - matches the IR form produced after InstCombine
optimizations

Added tests for both 32-bit and 64-bit BLSIC patterns

Assisted by: Claude Code, helped me understand
pattern-matching/intrinsics, and some file structure. As well as how
testing for LLVM works.

(cherry picked from commit 466503dcf2ae2e43126c1a6d8a5b204883d5b0c1)
https://invent.kde.org/qt/clang/llvm-project/-/commit/2ca1deea15528c1213c8a534b1a21053c33b8371

Git commit 7bd74c15be686b76aa34f8c322d33b9f0e9c76ea by Douglas Yung (on behalf of Jacob Crawley) on 22/07/2026 at 13:53..
[AArch64][LV] Adjust costs for low-VF interleaved access (#209441)

Addressing regression introduced by #205844 in which a significantly
slower SVE tail loop is generated.

The cost model for the case where the interleave factor is larger than
the VF has been adjusted to more accurately reflect the cost of the uzp
instructions generated by the deinterleave tree, and the cost of
legalizing the type of each subvector.

(cherry picked from commit 79e05f4aff2e5b9f0513c0539d146e44cc80193c)
https://invent.kde.org/qt/clang/llvm-project/-/commit/7bd74c15be686b76aa34f8c322d33b9f0e9c76ea

Git commit c22ddf0f405f9e21e9f0c51b85caf7b3d7147313 by Douglas Yung (on behalf of Antonio Frighetto) on 22/07/2026 at 13:53..
[MemCpyOpt] Ensure call slot optz does not lower destination alloca alignment

A destination alloca's alignment could have been unconditionally
overwritten, letting a lower-aligned source incorrectly undo a
previous alignment increase. This issue has been addressed by
considering the maximum alignment between the new source target
and current destination, adhering to what the existing comment
already promises.
https://invent.kde.org/qt/clang/llvm-project/-/commit/c22ddf0f405f9e21e9f0c51b85caf7b3d7147313

Git commit 2cb2b2979ca4ad0c8d2b836e687d82fbb75723db by Douglas Yung (on behalf of Simon Pilgrim) on 22/07/2026 at 13:54..
[X86] combineShiftRightLogical - fold srl(vecreduce_umax(x),bw-1) as MOVMSK signbit reduction (#210281)

VectorCombine may have folded:
  icmp_eq(vecreduce_or(splatsign(x)),0) --> icmp_sgt(vecreduce_umax(x),-1)

which DAG folds to:
  srl(vecreduce_umax(x),bw-1).

This match attempts to lower:
  srl(vecreduce_umax(x),bw-1) --> icmp_ne(movmsk(x),0) "any_of negative"
  srl(not(vecreduce_umax(x)),bw-1) --> icmp_eq(movmsk(x),0) "none_of negative"

The correct fix would be to improve vecreduce_or costs to prevent
VectorCombine doing this, but that change is far too big to be merged
into 23.x - so I've created the narrow backend fix.

Fixes #209714

(cherry picked from commit 8abc26930cf9ee0f059228acdbd1d22cd1c325e3)
https://invent.kde.org/qt/clang/llvm-project/-/commit/2cb2b2979ca4ad0c8d2b836e687d82fbb75723db

Git commit 2d5e67002c4281632cce3d12b9bfc16863d2f8f1 by Douglas Yung (on behalf of Mikołaj Piróg) on 22/07/2026 at 13:55..
[X86] Support apxf in attribute target (#184078)

As in title. This adds support for using apxf in attribute target.
Individual features are not supported for FMV but are supported for
enabling a feature for the function

Patch done with usage of Claude Code.

(cherry picked from commit 1d55a816c6dddfaacfd39f3235519a2389b56423)
https://invent.kde.org/qt/clang/llvm-project/-/commit/2d5e67002c4281632cce3d12b9bfc16863d2f8f1

Git commit 881e1cb71911cdce060845310a4c5aaa46b48324 by Douglas Yung (on behalf of Petr Hosek) on 22/07/2026 at 13:56..
[libcxx][NFC] Address -Wmicrosoft-cast in MSVC's exception_ptr (#210570)

This was introduced as part of #94977. Rather than suppressing the
warning with `#pragma clang diagnostic ignored`, we use
`reinterpret_cast` to avoid the implicit conversion.

(cherry picked from commit 16ffd27e3737c01cbabad6eed77b919dc977ad6c)
https://invent.kde.org/qt/clang/llvm-project/-/commit/881e1cb71911cdce060845310a4c5aaa46b48324

Git commit e241e1868b010e36813b4ba26da5f10a6ee096f7 by Douglas Yung (on behalf of Jonas Devlieghere) on 22/07/2026 at 13:56..
[DWARFLinker] Fix data race on the per-unit file-name cache (#208967)

CompileUnit::getDirAndFilenameFromLineTable reads and mutates the unit's
FileNames DenseMap without synchronization. During the parallel
type-name assignment phase a unit's cache is touched both by its own
worker and, through cross-unit type-name references
(addReferencedODRDies calling addDieNameFromDeclFileAndDeclLine) by
other units' workers.

The concurrent find/insert/grow corrupts the map and trips the
assertion:

```
Assertion failed: (TheBucket), function findBucketForInsertion, DenseMap.h
```

Guard the cache with a mutex. Store each entry in a heap-allocated pair
so the StringRefs handed back to callers stay valid across a concurrent
rehash. Otherwise a short (small-string-optimized) file name would move
when another insertion grows the map, dangling a StringRef already
returned.

(cherry picked from commit 499b69cf07e03a23a420ee773261fcfcfc1c3df9)
https://invent.kde.org/qt/clang/llvm-project/-/commit/e241e1868b010e36813b4ba26da5f10a6ee096f7

Git commit 2462eac065b11a3283d2247af841f33c4c4be477 by Douglas Yung (on behalf of Jonas Devlieghere) on 22/07/2026 at 13:57..
[DWARFLinker] Make synthetic type names deterministic under threading (#209553)

(cherry picked from commit 6bcdcb39c57ea926d3082ec3ecae74bf59b4658e)
https://invent.kde.org/qt/clang/llvm-project/-/commit/2462eac065b11a3283d2247af841f33c4c4be477

Git commit a94ef183551cb95b9ca59e6ea016451f17d7f553 by Douglas Yung (on behalf of Brian Cain) on 22/07/2026 at 13:58..
[docs][Hexagon] Add 23.x release notes for Hexagon changes (NFC)
https://invent.kde.org/qt/clang/llvm-project/-/commit/a94ef183551cb95b9ca59e6ea016451f17d7f553

Git commit 2f8eaf6ef04cb81fc98c30c1a8dd7fa1a0f4c43e by Douglas Yung (on behalf of Yanzuo Liu) on 22/07/2026 at 13:58..
[clang][Parser] Warn when the body of expansion statement is not a compound statement (#209229)

<https://eel.is/c++draft/stmt.expand#nt:expansion-statement>:

_expansion-statement_:
template for ( _init-statement<sub>opt</sub>_ _for-range-declaration_ :
_expansion-initializer_ ) _compound-statement_

(cherry picked from commit d13b8625eef0941f48b5af74e9fab953b6430eb2)
https://invent.kde.org/qt/clang/llvm-project/-/commit/2f8eaf6ef04cb81fc98c30c1a8dd7fa1a0f4c43e

Git commit 37532c319a905e75c6a9b028989da2d1b6073692 by Douglas Yung (on behalf of David Green) on 22/07/2026 at 13:59..
[SDAG] Use DAG.getTokenFactor in more places (#210949)

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

This fixes #189161 but I have not added a test case as the output is
in excess of 160000 lines long.

(cherry picked from commit ba836590ffed1305a770fc18f4a3f676f9829df1)
https://invent.kde.org/qt/clang/llvm-project/-/commit/37532c319a905e75c6a9b028989da2d1b6073692

Git commit 69873d3d1985f34fd16a3c5af89a00f9fc4df1fc by Douglas Yung (on behalf of Med Ismail Bennani) on 22/07/2026 at 14:00..
[lldb] Gate `PolicyStack::Current()` log behind verbose (#209527)

`Process::GetState()` calls `PolicyStack::Get().Current()` on every
prompt redraw, so the previous unconditional LLDB_LOG at the read site
fired on every keypress once `log enable lldb process` was on, drowning
out any other process log output. Keep the dump for when it's actually
wanted, but only fire it if the log is set to verbose.

Signed-off-by: Med Ismail Bennani <[email protected]>
(cherry picked from commit c7a0afe5049a3d4789f34a8d746c6a45d73557b4)
https://invent.kde.org/qt/clang/llvm-project/-/commit/69873d3d1985f34fd16a3c5af89a00f9fc4df1fc

Git commit b82e355d1b5ffe8e9ef16df751ad5151856c0a0d by Douglas Yung (on behalf of Andy Ames) on 22/07/2026 at 14:01..
[analyzer] Fix crash in RegionStoreManager::bindArray from constructor array-to-pointer decay (#210649)

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

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

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

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

Fixes #210183

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

---------

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

Git commit e23de9497b1f3b44a7a6b8e9dc1002496485e242 by Douglas Yung (on behalf of John Paul Jepko) on 22/07/2026 at 14:01..
[analyzer] Fix StdVariantChecker crash on std::get with a non-ptr arg (#210167)

When `std::get` is called on a dereferenced integer-to-pointer cast, the
checker `alpha.core.StdVariant` crashes. Minimal reproducer:

```
std::get<int>(*(std::variant<int, char> *)11);
```

Godbolt reproducer - https://godbolt.org/z/4EKe1PrKb

The root cause is that `StdVariantChecker::handleStdGetCall()` calls
`SVal::getType()` on any non-unknown argument, then calls
`getPointeeType()` on the result while assuming it is a pointer type. In
the case of a concrete integer cast to a pointer and then dereferenced,
it is modeled as `loc::ConcreteInt`, whose recovered type is an integer.
`getPointeeType()` on such an input returns a null QualType, on which
`getTypePtr()` crashes.

Fix the crash by using the argument's static type rather than recovering
its SVal, eliminating the need to guard and call `getPointeeType()`.

(cherry picked from commit accd1ed5226b4a8009c33f0a6d1bcfe58902f69e)
https://invent.kde.org/qt/clang/llvm-project/-/commit/e23de9497b1f3b44a7a6b8e9dc1002496485e242

Git commit 6f033fece5f5ae501698b9f49f3bca3f1fa19b38 by Douglas Yung (on behalf of Prabhu Rajasekaran) on 22/07/2026 at 14:03..
[llvm-readobj] Print all callgraph sections (#198929)

Ensure that `llvm-readobj` / `llvm-readelf` processes and dumps all
SHT_LLVM_CALL_GRAPH sections present in an object file, rather
than just the first one.

**Motivation:**
Consider this `foo.s` file
```
.pushsection .text, "axG", %progbits, foo
  .globl foo
  foo:
  ret
  .pushsection .llvm.callgraph, "?", %llvm_call_graph
    .byte 0, 0
    .dc.a foo
    .quad 0
  .popsection
.popsection

.pushsection .text, "axG", %progbits, bar
  .globl foo
  bar:
  ret
  .pushsection .llvm.callgraph, "?", %llvm_call_graph
    .byte 0, 0
    .dc.a bar
    .quad 0
  .popsection
.popsection
```
`clang -c foo.s && llvm-readelf --elf-output-style=JSON --pretty-print
--call-graph-info foo.o` on that shows that there is only one record
reported because the current implementation just looked at the first
SHT_LLVM_CALL_GRAPH section and then ignored all others. This patch will
address this gap by iterating over all the SHT_LLVM_CALL_GRAPH sections.

(cherry picked from commit eb7677457c1611c02a6362d9eae043987c02ea25)
https://invent.kde.org/qt/clang/llvm-project/-/commit/6f033fece5f5ae501698b9f49f3bca3f1fa19b38

Git commit 6c8106221abb8ecf67527ec2707157d4fb1c1f8b by Douglas Yung (on behalf of Sudharsan Veeravalli) on 22/07/2026 at 14:04..
[RISCV] Support uimm5 operands for Xqcicm cmovs in RISCVExpandPseudoInsts (#210955)

`expandCCOpToCMov` was only accepting signed 5-bit immediates before
forming `Xqcicm` conditional-move pseudos. Valid `uimm5` operands for
unsigned compare forms such as `QC_MVGEUI` and `QC_MVLTUI` were not
being handled leading to a crash.

Track whether the selected conditional-move opcode expects a signed or
unsigned immediate, and validate the RHS against the matching range.

(cherry picked from commit 9bcb851e86941117ec9e82db8986ed301f929647)
https://invent.kde.org/qt/clang/llvm-project/-/commit/6c8106221abb8ecf67527ec2707157d4fb1c1f8b

Git commit ed059dae037e650b3f7670acc36b897283fe858f by Douglas Yung (on behalf of Sudharsan Veeravalli) on 22/07/2026 at 14:04..
[RISCV] Avoid forming Zilsd pairs with x0 for non-x0 register classes (#211019)

The pre-RA Zilsd optimizer allowed a pair when both stored values came
from the same virtual register if that virtual register was defined by a
copy from X0. This is only valid when the virtual register class can
actually contain X0.

Check the virtual register class before treating the value as `x0_pair`.
This prevents forming an invalid paired store for register classes such
as `GPRNoX0`.

Without this change we were hitting the following assertion in
`RISCVLoadStoreOptimizer`:

```
assert(
    FirstReg != SecondReg &&
    "First register and second register is impossible to be same register");
```

(cherry picked from commit 6b408bf0da2901a5264a39b7571f5e68b846d94a)
https://invent.kde.org/qt/clang/llvm-project/-/commit/ed059dae037e650b3f7670acc36b897283fe858f

Git commit b2628f061ea76a2beb09228701719916f5e355bf by Douglas Yung (on behalf of jay0x) on 22/07/2026 at 14:05..
[flang][Lower][OpenMP] Fix reduction on array sections aborting in lowering (#209701)

**Summary**

This regression was introduced by #196094, which added a special
lowering path for reductions on a single array element, such as `a(2)`.

The problem is that Flang also treated an array section like `a(2:96)`
as if it were a single element. Because of this, the section was sent to
a code path that only supports scalar elements.

That path produced an array type that the reduction initialization code
could not handle, so Flang reached a `TODO` and aborted with a “not yet
implemented” error.

**Fix**

The fix is to use the special element path only when the expression has
rank 0, which means it represents one single value. Array sections have
rank greater than 0, so they should continue through the existing
boxed-array path.

Fixes : [209462](https://github.com/llvm/llvm-project/issues/209462)

---------

Co-authored-by: Jay Satish Kumar Patel <[email protected]>
(cherry picked from commit 6c560cddfb1e206678866c6822baabcdcee2343f)
https://invent.kde.org/qt/clang/llvm-project/-/commit/b2628f061ea76a2beb09228701719916f5e355bf

Git commit 165c472d65cd62eb332246eb39901603e4b1e4ce by Douglas Yung (on behalf of Louis Dionne) on 22/07/2026 at 14:06..
[libc++] Don't require complete types in vector<T>::empty() (#210754)

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

Fixes #210732

(cherry picked from commit 17ac8fdd95283110a14f1de8c15a0fc661119296)
https://invent.kde.org/qt/clang/llvm-project/-/commit/165c472d65cd62eb332246eb39901603e4b1e4ce