[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 aef1e4f249856ce1b9e8362fee75619f3fa8efcf to a67429f21b882e546555a3d1d9d45363ae1be51b
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 b11881e5daa280d322127d4c51dcf472dbcc1dd5 by GitHub (on behalf of Aiden Grossman) on 21/07/2026 at 23:21..
[BranchFolding] Fold away subsequent identical branches

If we have a BB that has a single conditional branch instruction it that
is identical to the previous block's branch instruction, we can delete
the BB as it is redundant.

This doesn't directly impact performance as such instructions are never
executed, but this can help decrease code size which can help with
overall icache pressure (though likely only slightly). The biggest
impact would probably be fitting more instructions into a single cache
line. This is probably almost a no-op with PLO but definitely doesn't
hurt.

Fixes #202763.

Reviewers: RKSimon, arsenm, krzysz00, topperc, lei137

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

Git commit 8b9cce358bef26ae4cb9275dd6a43f903bafbaa0 by GitHub (on behalf of jimingham) on 21/07/2026 at 23:31..
Make result variables obey their dynamic values in subsequent expressions

This is a resubmit of the original patch: 6344e3aa8106dfdfb30cac36c8ca02bc4c52ce24:

Make result variables obey their dynamic values in subsequent
expressions (#168611)

When I originally submitted this, it caused intermittent flakey failures
on systems I didn't have access to, and I didn't have time to sort them
out, so I reverted the patch. I'm resubmitting this so I can run the
bots on it a few rounds to see if I can reproduce and diagnose those
intermittent failures.

Here's the commit log from the original submission describing the
change:

When you run an expression and the result has a dynamic type that is
different from the expression's static result type, we print the result
variable using the dynamic type, but at present when you use the result
variable in an expression later on, we only give you access to the
static type. For instance:

```
(lldb) expr MakeADerivedReportABase()
(Derived *) $0 = 0x00000001007e93e0
(lldb) expr $0->method_from_derived()
                ^
                error: no member named 'method_from_derived' in 'Base'
(lldb)

```

The static return type of that function is `Base *`, but we printed that
the result was a `Derived *` and then only used the `Base *` part of it
in subsequent expressions. That's not very helpful, and forces you to
guess and then cast the result types to their dynamic type in order to
be able to access the full type you were returned, which is
inconvenient.

This patch makes lldb retain the dynamic type of the result variable
(and ditto for persistent result variables).

It also adds more testing of expression result variables with various
types of dynamic values, to ensure we can access both the ivars and
methods of the type we print the result as.
https://invent.kde.org/qt/clang/llvm/-/commit/8b9cce358bef26ae4cb9275dd6a43f903bafbaa0

Git commit 3a2ea7f45682105d26334948d233d10e47675745 by GitHub (on behalf of Alex Langford) on 22/07/2026 at 00:06..
[lldb] Change DynamicLoaderDarwin::Segment::name type (#210797)

No need to be a ConstString, Mach-O segment names are always 16 bytes
long. Because this struct is shared for both segment_command and
segment_command_64, I opted to keep the definition instead of replacing
it with one of llvm's MachO structs.

I chose a 17-byte character array so that whatever goes into it can
always be treated as a null-terminated C string.
https://invent.kde.org/qt/clang/llvm/-/commit/3a2ea7f45682105d26334948d233d10e47675745

Git commit acb8fbe83ff12711317118b8c9831905d301b56a by GitHub (on behalf of Jonas Devlieghere) on 22/07/2026 at 00:13..
[DWARFLinker] Fix placement lost-update crash in parallel marking (#211009)
https://invent.kde.org/qt/clang/llvm/-/commit/acb8fbe83ff12711317118b8c9831905d301b56a

Git commit 3f0919e8d986b829494fec58d8a8fc0ae043aae0 by GitHub (on behalf of Thrrreeee) on 22/07/2026 at 00:25..
[BOLT][RISCV] Support the TLS global-dynamic relocation (#209995)

This patch adds BOLT support for the RISC-V TLS global-dynamic
relocation `R_RISCV_TLS_GD_HI20`. Classifying it as both a **TLS
relocation** and a **GOT-style relocation** allows BOLT to preserve the
relocation, recover the actual GOT entry address from the linked
instructions, and symbolize the instruction pair.

The RISC-V TLS relocation test is extended to cover a global-dynamic
sequence and verify that BOLT reconstructs the `AUIPC`/`PCREL_LO12` pair
correctly.
https://invent.kde.org/qt/clang/llvm/-/commit/3f0919e8d986b829494fec58d8a8fc0ae043aae0

Git commit afb68446b493597aec089746957dc36060925679 by GitHub (on behalf of Jan Leyonberg) on 22/07/2026 at 00:41..
[CIR][OpenMP] Add host op filtering pass to CIR pipeline (#209592)

This patch adds the host op filtering pass which prevents host code
being lowered when compiling for the target device.
https://invent.kde.org/qt/clang/llvm/-/commit/afb68446b493597aec089746957dc36060925679

Git commit 14bfc424ae77976e05582ff38896caec399f2837 by GitHub (on behalf of Prasoon Kumar) on 22/07/2026 at 01:10..
Reland "[lit] Migrate lit to ProcessPoolExecutor (#202681)" (#209076)

We want lit's test-execution engine on concurrent.futures.ProcessPoolExecutor
instead of multiprocessing.Pool as it fixes two latent bugs in the old wait
loop and is groundwork for a planned ThreadPoolExecutor/asyncio backend. It
landed as #202681 but was reverted in #206138. The reverted code deadlocks
due to two independent CPython bugs.

submit() blocks holding _shutdown_lock once the executor's wakeup pipe
fills past 16,384 undrained writes, since its own manager thread needs
that same lock to drain it (cpython gh-105829). Separately, shutdown(wait=True)
deadlocks on macOS because join_executor_internals() joins the call queue
before the workers, the reverse of the order macOS needs.

Fix: bound outstanding futures to SUBMISSION_WINDOW_PER_WORKER * workers
and submit one new test per completion instead of all up front, so the
pipe can never fill (LIT_SUBMISSION_WINDOW=0 restores the old behavior for
debugging). cancel_join_thread() before shutdown(wait=True) fixes the
macOS ordering. Also reap SIGKILL'd workers after abort instead of
leaving zombies. 

---------

Signed-off-by: Prasoon Kumar <[email protected]>
https://invent.kde.org/qt/clang/llvm/-/commit/14bfc424ae77976e05582ff38896caec399f2837

Git commit 373df745fbffc01b1f3469a12fcef03343f843f5 by GitHub (on behalf of Kane Wang) on 22/07/2026 at 01:16..
[RISCV][GlobalISel] Legalize G_ATOMICRMW_MAX/MIN/UMAX/UMIN (#210891)

Add a legalizer rule that marks these legal at `sXLen` under `+a`
(selecting `amomax.w/d`, and `amomax.b/h` for sub-word under `+zabha`
via the existing widen-scalar-while-preserving-the-memoperand path), and
handle the `llvm.riscv.masked.atomicrmw.{max,min,umax,umin}` intrinsics
the same way as `add/sub/xchg` so sub-word values without `+zabha` use
the LR/SC masking pseudos. There is no `__atomic_fetch_max/min` libcall,
so unlike `add/and/or/xor` the rule does not libcall the no-A case; that
case is already lowered by an IR-level compare-exchange loop and never
reaches GlobalISel, so the rule marks it unsupported to keep the rule
set well-defined.

Updates `legalizer-info-validation.mir` for the newly defined rules and
adds `atomicrmw-max-min-umax-umin.ll`.
https://invent.kde.org/qt/clang/llvm/-/commit/373df745fbffc01b1f3469a12fcef03343f843f5

Git commit 0cf295574bbef856646e8321e4e798128b84b73b by GitHub (on behalf of Chris Apple) on 22/07/2026 at 01:51..
[compiler-rt][rtsan] Loosen requirements of halt_on_error test (#210734)

Some systems may call other intercepted functions during the course of a
`malloc`. This would result in some error stack such as:

```
 ERROR malloc
     ERROR pthread_mutex_lock
     ERROR pthread_mutex_unlock
     
 ERROR free
     ERROR pthread_mutex_lock
     ERROR pthread_mutex_unlock
```

We support this as RTSan, but this test would be overly specific on
those platforms. As written, this requires "only malloc, then free
immediately after". The change makes this "at least malloc is called,
and then later at least free is called". This still keeps the spirit of
the check the same but allows for more (valid) interpretation in
between.



NOTE:
In the future, we may want to consider doing something similar here:

https://github.com/llvm/llvm-project/blob/40c4fea67f49b841bd064624219efceab91b65e0/compiler-rt/test/rtsan/stack_suppressions.cpp#L65

This specifies ONLY 7 suppressions should happen here which is extremely
specific. However I did not change this because it's a little trickier.
We don't really have a test for this stack suppressions method anywhere
else. We could do something like "at least 7 things should be
suppressed", but it's messier so I left that for a future exercise.
https://invent.kde.org/qt/clang/llvm/-/commit/0cf295574bbef856646e8321e4e798128b84b73b

Git commit 494a8482a0663cfb8eec515995666fea10aa175a by GitHub (on behalf of Nico Weber) on 22/07/2026 at 01:51..
[gn build] Port acb8fbe83ff1 (#211156)
https://invent.kde.org/qt/clang/llvm/-/commit/494a8482a0663cfb8eec515995666fea10aa175a

Git commit 3c8a9094811a2291d65473b290478c14d1e193ab by GitHub (on behalf of Nico Weber) on 22/07/2026 at 01:51..
[gn build] Port db816fe2ed4e (#211157)
https://invent.kde.org/qt/clang/llvm/-/commit/3c8a9094811a2291d65473b290478c14d1e193ab

Git commit 564b027db16dc14c2027cd5a2fbb8bf1d3877b85 by GitHub (on behalf of David Brittain) on 22/07/2026 at 01:57..
[clang][Modules] Keep current-TU global-module-fragment internal-linkage functions viable in overload resolution (#210825)

Fixes #210822

A `static` (or anonymous-namespace) function declared in the global
module fragment of the current TU is usable within the module unit
([module.global.frag]/p1), but `Sema::AddOverloadCandidate` dropped it
from the overload set when `Function->isInAnotherModuleUnit()` misfired
— which it does when the enclosing template is instantiated after the
GMF closes (pending instantiations run in
`ActOnEndOfTranslationUnitFragment`, before the named module is in
scope). The candidate was removed with the hidden
`ovl_fail_module_mismatched` kind, so the error had no candidate notes.

The existing carve-out (#104701) only exempted inline /
implicitly-instantiated GMF functions. This also exempts
internal-linkage functions from the current TU's GMF
(`isFromGlobalModule() && !isFromASTFile()`); genuinely imported
internal-linkage functions stay subject to the rule.

`clang/test/Modules` and `clang/test/CXX/module` show no new failures;
the `expose-static-inline-from-gmf-*` tests still pass. Adds a
regression test.

This change was developed with substantial assistance from an AI tool
(Claude Code). The AI carried out the investigation and root-cause
analysis, wrote the code change and the regression test, and drafted
this description.
https://invent.kde.org/qt/clang/llvm/-/commit/564b027db16dc14c2027cd5a2fbb8bf1d3877b85

Git commit 98fe06cb6487cf23d5a56bd5ff0c6b4e378d1be3 by GitHub (on behalf of Lang Hames) on 22/07/2026 at 02:17..
[orc-rt] Rename CallVia* utils to reflect destination. NFC. (#211150)

Rename Session::CallViaSession to Session::ControllerCaller, and test
utility CallViaMockControllerAccess to CallFromController.

The old names described who was routing the calls, but this is implicit
at the call-site anyway (CallViaSession was a method on Session, and
CallViaMockControllerAccess took a MockControllerAccess argument). The
new names reflect the call destination, which is the thing clients care
about.
https://invent.kde.org/qt/clang/llvm/-/commit/98fe06cb6487cf23d5a56bd5ff0c6b4e378d1be3

Git commit 46858d55e80abb88037c57fd1134a526500f6732 by GitHub (on behalf of aokblast) on 22/07/2026 at 03:25..
[BOLT] Implement platform independent distribution and shuffle algorithm (#206554)

std::uniform_int_distribution and std::shuffle are
implementation-defined, so binary built with libc++ and libstdc++ can
produce different fragment layouts when using SplitStrategy. In this
case, the FreeBSD build emits only one fragment instead of three.

The output geenrate by --bolt-seed should be deterministic for the same
binary regardless of the standard library implementation. Implement a
portable shuffle and uniform distribution to guarantee identical results
for a given seed.

After this change, we generate 1 fragment, which decrease the strength
of the testcase. As a result, we change the seed to different value to
allow it generate different number of fragments.

Also, replace in-place file modifcation with a write-and-replace
approach for better portability in sed.
https://invent.kde.org/qt/clang/llvm/-/commit/46858d55e80abb88037c57fd1134a526500f6732

Git commit e6190fab2e05e4ba8646af9cf32314fd75e6cccd by GitHub (on behalf of aokblast) on 22/07/2026 at 03:26..
[clang] Switch to Default PIE on FreeBSD (#206139)

We have started to compile the binary in our base as PIE by defualt. It
makes sense to compile the binary to PIE by default in toolchain as
Linux now. Also, extended testcases to support default PIE and no-pie
parameter in freebsd.c and hip-fpie-option.hip.
https://invent.kde.org/qt/clang/llvm/-/commit/e6190fab2e05e4ba8646af9cf32314fd75e6cccd

Git commit 9bcb851e86941117ec9e82db8986ed301f929647 by GitHub (on behalf of Sudharsan Veeravalli) on 22/07/2026 at 03:33..
[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.
https://invent.kde.org/qt/clang/llvm/-/commit/9bcb851e86941117ec9e82db8986ed301f929647

Git commit d4e853f37031ff0eee47d323cbc8bc703b5a0ec7 by GitHub (on behalf of Tejas Joshi) on 22/07/2026 at 04:10..
[NVPTX] Fix illegal .ftz modifier for setp and neg PTX instructions for bf16 (#211128)

This patch disables emitting .ftz modifier for bf16 and bf16x2 type setp
and neg instructions, the PTX ISA does not specify this modifier for the
same. FNEG_H already correctly handles fneg for bf16, so remove the
redundant bf16 FNEG16 pattern.
https://invent.kde.org/qt/clang/llvm/-/commit/d4e853f37031ff0eee47d323cbc8bc703b5a0ec7

Git commit 5602b981932fedc686b874ffe6ed3164b34a49e7 by GitHub (on behalf of Lang Hames) on 22/07/2026 at 04:13..
[orc-rt] Run controller-call continuations from Session (#211166)

A controller call's on-complete handler may run managed code, so it must
be dispatched by the Session under a ManagedCodeTaskGroup token, not
invoked directly by the ControllerAccess (which previously held it as a
plain callable and called it itself -- untokened and undispatched).

Wrap it in an opaque ControllerAccess::OnControllerCallReturn that
implementations can hold but not call. They complete it via exactly one
of three Session-provided paths:

- handleControllerCallResult -- the controller returned a result;
dispatches the handler under a fresh token. Asserts the managed-code
group is still open (i.e. before notifyDisconnected).

- failPendingControllerCall -- an already-enqueued call is failed
because the connection dropped before a result arrived (the disconnect
drain); dispatches the handler under a token with a disconnect error.

- failControllerCallInline -- a call made from within callController
while already disconnecting, which can never be enqueued; runs the
handler inline with a disconnect error, where the caller (and its token)
is still on the stack.

Together these guarantee a controller call's handler always runs exactly
once, with a result or a disconnect error, and never runs managed code
without a token. Only the success path takes a result value; the two
failure paths produce the canonical disconnect error internally, so it
can't be gotten wrong. InProcessControllerAccess and the Session unit
tests are updated.
https://invent.kde.org/qt/clang/llvm/-/commit/5602b981932fedc686b874ffe6ed3164b34a49e7

Git commit 6b408bf0da2901a5264a39b7571f5e68b846d94a by GitHub (on behalf of Sudharsan Veeravalli) on 22/07/2026 at 04:34..
[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");
```
https://invent.kde.org/qt/clang/llvm/-/commit/6b408bf0da2901a5264a39b7571f5e68b846d94a

Git commit 6793bb48ac7517ea1e965de540c75359e465c355 by GitHub (on behalf of Matt Arsenault) on 22/07/2026 at 04:41..
libclc: Fix UB in trig functions with nan inputs (#211047)
https://invent.kde.org/qt/clang/llvm/-/commit/6793bb48ac7517ea1e965de540c75359e465c355

Git commit a67429f21b882e546555a3d1d9d45363ae1be51b by GitHub (on behalf of Keno Fischer) on 22/07/2026 at 05:08..
[LoopInfo] Factor use-scan of isBlockInLCSSAForm [NFC] (#211087)

[Factored out of llvm/llvm-project#151062 by review request; AI
Disclosure: Done by Claude]

Split the per-use logic of isBlockInLCSSAForm into a separate helper
that answers whether a single use of a value defined in a loop is
contained within the loop for LCSSA purposes.
https://invent.kde.org/qt/clang/llvm/-/commit/a67429f21b882e546555a3d1d9d45363ae1be51b