[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/petar-avramovic/fptrunc-bf16-fix'.
Changed from 0000000000000000000000000000000000000000 to 1c1a067652a5874db01548d15a8eafee3e85707d
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 29bc0749034c4f2bda0752360ecacd4e89d7439c by GitHub (on behalf of Ebuka Ezike) on 29/07/2026 at 11:30..
[lldb] Fix crash on creating string error (#212503)

It crashes because the `default` error string may not be a format string
compared to the `fallback` error string
https://invent.kde.org/qt/clang/llvm-project/-/commit/29bc0749034c4f2bda0752360ecacd4e89d7439c

Git commit 5989d40ab1d0db8333b5976d957a49525d36cf35 by GitHub (on behalf of jeanPerier) on 29/07/2026 at 11:31..
[flang] Wire allocation-placement into the optimizer pipeline (default off) - memory passes unification [3/5] (#210745)

Add a hidden -enable-allocation-placement flag that, when set, replaces
the stack-arrays and memory-allocation-opt passes in the default FIR
optimizer pipeline with the unified allocation-placement pass. The flag
is off by default, so the legacy passes remain the default path and
behavior is unchanged.

When enabled, the pass runs with its default byte-size thresholds; the
-fstack-arrays strategy is forwarded through the new stackArrays option.

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

Git commit 6e116760ca4010be890b7fa39c93f2c902ab2a31 by GitHub (on behalf of Alexey Bataev) on 29/07/2026 at 11:42..
[SLP]Initial support for copyables in fmuladd intrinsic

Adds llvm.fmuladd as a main operation for copyable elements. A
non-fmuladd lane V is modeled as fmuladd(0.0, -0.0, V), which equals
-0.0 + V == V for every V. Only the addend operand is supported for
now; multiplicand operands may be added later.

Reviewers: bababuck, hiraditya, RKSimon

Pull Request: https://github.com/llvm/llvm-project/pull/211245
https://invent.kde.org/qt/clang/llvm-project/-/commit/6e116760ca4010be890b7fa39c93f2c902ab2a31

Git commit a41d59740625948c6b334abbf921d0888b6f0377 by GitHub (on behalf of Hui) on 29/07/2026 at 11:54..
[libc++][test][NFC] remove old UNSUPPORTED clang from clear_padding.pass.cpp (#212690)

Follow up PR for comment
https://github.com/llvm/llvm-project/pull/211258/changes#r3663614103

I think I must have made an oversight while resolving a merge conflict
https://invent.kde.org/qt/clang/llvm-project/-/commit/a41d59740625948c6b334abbf921d0888b6f0377

Git commit 2545a108f4d173ed509e3eea33753227bdd6f847 by GitHub (on behalf of Florian Hahn) on 29/07/2026 at 12:02..
[VPlan] Compute cost of some VPWidenIntOrFpInductions in VPlan (#202232)

Add initial implementation of VPWidenIntOrFpInductionRecipe::computeCost,
handling un-truncated inductions.

For the first patch, only compute costs in VPlan if there are no
truncated inductions (in that case, there are additional differences for
the cost model, as previously we would not cost the truncate properly)
and the vector loop won't get unrolled (no induction cost).

Note that some decision change. This is due to the legacy cost model
computing the cost of the original IR, where the induction is scaled in
the loop in each iteration (e.g. with mul), while in the vector loop we
scale the increment, and there is just an add to increment the
induction. This is more accurate than the legacy cost computation.

PR: https://github.com/llvm/llvm-project/pull/202232
https://invent.kde.org/qt/clang/llvm-project/-/commit/2545a108f4d173ed509e3eea33753227bdd6f847

Git commit 6314c9731eafa68837bbbab65e347922134b004a by GitHub (on behalf of firmiana) on 29/07/2026 at 12:05..
[lldb][NFC] Explicitly list unsupported DWARF expression opcodes (#210363)

This PR addresses
[#202251](https://github.com/llvm/llvm-project/issues/202251).

Several opcodes recognized by LLDB's DWARF expression decoding logic
currently have no explicit `case` in `DWARFExpression::Evaluate`. They
therefore reach the generic default path, which makes it unclear whether
their evaluator status is intentional or an omission.

Explicitly list the affected opcodes and group them with the existing
`DW_OP_xderef`, `DW_OP_xderef_size`, `DW_OP_call2`, and `DW_OP_call4`
cases. All twelve known but unsupported opcodes now share an
`unimplemented opcode` return, while `default` remains responsible for
unknown and vendor-handled opcodes. No opcode evaluation semantics
change.

The affected opcodes are `DW_OP_call_ref`, `DW_OP_constx`,
`DW_OP_const_type`, `DW_OP_regval_type`, `DW_OP_deref_type`,
`DW_OP_xderef_type`, `DW_OP_reinterpret`, and
`DW_OP_GNU_implicit_pointer`.

## Tests

The existing per-opcode status-locking tests in
`DWARFExpressionTest.cpp` cover all affected cases and are updated to
check the unified diagnostic.
https://invent.kde.org/qt/clang/llvm-project/-/commit/6314c9731eafa68837bbbab65e347922134b004a

Git commit d630025295d5ef6724ec9deab162b983ffee6638 by GitHub (on behalf of Felix Ye) on 29/07/2026 at 12:05..
[mlir][toy] Fix Ch6/Ch7 llvm-lowering tests (#212118)

Add missing `| FileCheck %s` to `RUN` lines so `CHECK` lines can be
verified. Also correct the expected result from `30` to `36`. The result
should be `6*6=36`.

The example in the tutorial is correct (`3.600000e+01`).
https://mlir.llvm.org/docs/Tutorials/Toy/Ch-6/

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

Git commit c53789fcf54979f7986d2e396920b725ce88f3e4 by GitHub (on behalf of Nikolas Klauser) on 29/07/2026 at 12:09..
[libc++][NFC] Clean up atomic_support.h (#212464)

We don't support any compilers which don't have the atomic builtins, so
we don't need to check whether they exist. There is also no need for an
anonymous namespace, since all the functions are inline.
https://invent.kde.org/qt/clang/llvm-project/-/commit/c53789fcf54979f7986d2e396920b725ce88f3e4

Git commit 25cc0d29e2c34966116f897e0db496d94cf91acf by GitHub (on behalf of Sander de Smalen) on 29/07/2026 at 12:09..
[AArch64] NFC: simplify isCopyInstrImpl expression (#212487)

To something more intuitive by applying the following logic:
* `!isVirtual()` -> `isPhysical()`
* `!isPhysical()` -> `isVirtual()`
* `(a || b) && (!a || c)` -> `(!a && b) || (a && c)`
https://invent.kde.org/qt/clang/llvm-project/-/commit/25cc0d29e2c34966116f897e0db496d94cf91acf

Git commit f53596de0e42e9df10831cb50438bc8b85f826b3 by GitHub (on behalf of Folkert de Vries) on 29/07/2026 at 12:11..
[MIPS][clang] make `_Complex` ABI match GCC (#212119)

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

From the edits to the release notes:

- On MIPS, a `_Complex` value with an integer element type is now
returned packed
into a single integer register when it fits in one, matching GCC. A
`_Complex char` or
`_Complex short`, and on N32/N64 also a `_Complex int`, is no longer
returned
with one part per register. `-fclang-abi-compat=23` restores the
previous
  behavior. (#GH212109)

- On MIPS N32/N64, a `_Complex float` or `_Complex double` argument is
now packed
into integer registers, or onto the stack, once there is no longer room
to give
each of its parts a floating-point register, matching GCC. Clang
previously
always passed the parts separately. `-fclang-abi-compat=23` restores the
previous
  behavior. (#GH212109)
https://invent.kde.org/qt/clang/llvm-project/-/commit/f53596de0e42e9df10831cb50438bc8b85f826b3

Git commit 1d6a3dd80b48ad1990ed5e3e11acd3b06d2909b6 by GitHub (on behalf of antoine moynault) on 29/07/2026 at 12:19..
[LinkerWrapper][test] fix test offload-wrapper.ll (#212713)

The llc RUN command added in #212614 needs the X86 backend registered
https://invent.kde.org/qt/clang/llvm-project/-/commit/1d6a3dd80b48ad1990ed5e3e11acd3b06d2909b6

Git commit deed195c31f0ece487aa5ef79c90633860f10b93 by GitHub (on behalf of Arseniy Zaostrovnykh) on 29/07/2026 at 12:27..
[analyzer] Prune infeasible states related to concrete ints early to fix a crash (#210912)

RangedConstraintManager discards a simplified symbol if it reduces to a
concrete integer. This leads to delayed realization that some state
might be infeasible (because the concrete integer does not fit in the
assumed range), which might produce unexpected null pointers on the
following state splits.

PthreadLockChecker has fallen just into this trap. It assumes
`pthread_mutex_lock` is always called in a feasible state, which is was
not true.
In particular, in ZFS the analyzer crashes when runs in CTU mode because
it reaches `pthread_mutex_lock()` in over-constraint state (see the
reduced example in the first commit).

Checkers rely on the invariant that a state split can never result in
both `StateRef`s being null. To fix this violation of the invariant,
this patch helps RangedConstraintManager to realize a state is
infeasible and abort its exploration early so no follow-up state split
produce unexpected null-null pair.

Assisted by Claude Opus 4.8

--
CPP-8665
https://invent.kde.org/qt/clang/llvm-project/-/commit/deed195c31f0ece487aa5ef79c90633860f10b93

Git commit ed389ca093797baab0bcc95ffd2b6ca41741c40d by GitHub (on behalf of Aochang Liu) on 29/07/2026 at 12:29..
[CodeGen][ARM] Add regression tests for #202263 (#202599)

The underlying issue—RegisterCoalescer eliminating an undef COPY and
leaving a partial subregister redef that reads a value that no longer
exists—was fixed in #204039.

This PR adds the regression coverage originally developed alongside the
fix attempt, so the pattern remains covered:

- an end-to-end IR test that checks the generated assembly with
FileCheck;
- a focused single-pass `-run-pass=register-coalescer` MIR test using
`-verify-coalescing`, which reproduces the "Instruction is reading
nonexistent value" verifier error from #202263 when #204039 is reverted,
and passes with the fix applied.

Fixes #202263
https://invent.kde.org/qt/clang/llvm-project/-/commit/ed389ca093797baab0bcc95ffd2b6ca41741c40d

Git commit 1c1a067652a5874db01548d15a8eafee3e85707d by Petar Avramovic on 29/07/2026 at 15:10..
GlobalISel: Fix lowerMergeValues when dst type is float

Lowering is done in the integer domain. Similar to the type
mismatch when dst is a pointer, make a bitcast when dst is float.
https://invent.kde.org/qt/clang/llvm-project/-/commit/1c1a067652a5874db01548d15a8eafee3e85707d