[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/tonykuttai/05-08-_powerpc_add__float16_support_for_power8_'.
Changed from cf06e354f7ffbd0c60bd61be1fd5858493908850 to ef06063d15e4fbecee1c659aa29ac9a41e580d01
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 f8e258866980da486756e241016dd33ae68450be by GitHub (on behalf of Louis Dionne) on 21/07/2026 at 11:21..
[libc++] Include sizes in string benchmark names (#210795)

Otherwise we'd have duplicate benchmark names.
https://invent.kde.org/qt/clang/llvm-project/-/commit/f8e258866980da486756e241016dd33ae68450be

Git commit 7f49d95c09e8a22a6de737ae6006edbb3a0adfca by GitHub (on behalf of Louis Dionne) on 21/07/2026 at 11:22..
[libc++][NFC] Fix synopsis comment for error_condition::message() (#210724)

The method was marked as noexcept in the synopsis, but it's neither
marked noexcept in the spec nor in our implementation.
https://invent.kde.org/qt/clang/llvm-project/-/commit/7f49d95c09e8a22a6de737ae6006edbb3a0adfca

Git commit df4bb1f3106d39e5c6b767a28c0531efbbebc2d2 by GitHub (on behalf of Louis Dionne) on 21/07/2026 at 11:23..
[libc++] Compose the test suite Lit site config from harness and installation substitutions (#209638)

This patch restructures how libc++'s Lit site config is generated.
Instead of relying on the user-selected configuration file to include
the CMake bridge, it composes a site configuration from multiple
independent bits.

Importantly, it splits substitutions that pertain to the harness setup
(e.g. where to find Python) and substitutions that pertain to libc++
itself (e.g. the path to libc++ headers). This split and the top-level
composition of a site config file are incremental steps towards
decoupling the test suite from libc++'s own build.
https://invent.kde.org/qt/clang/llvm-project/-/commit/df4bb1f3106d39e5c6b767a28c0531efbbebc2d2

Git commit ad3f09c7de3da1f023bc1134eaa33be6d39cc9ca by GitHub (on behalf of Gábor Horváth) on 21/07/2026 at 11:33..
[ADT] Add single-pass merge for ImmutableSet/ImmutableMap (#209807)

The immutable-set/map dataflow joins merged two containers by inserting
the
elements of one into the other one at a time, costing O(|B| * log|A|)
and
re-copying shared spine nodes on every insert.

Add a single-pass, structure-sharing tree merge on ImutAVLFactory
(mergeTrees), exposed as ImmutableSet::Factory::unionSets and
ImmutableMap::Factory::mergeWith. It recurses over the larger operand
and
splits the smaller at each key, returning non-overlapping subtrees
unchanged,
so each spine node is copied at most once: O(|B| * log(|A|/|B| + 1)).

Two flags tune it for the different joins:
* KeepUnmatched - keep keys unique to one side (set union / a lattice
join
with an identity) vs. pass them through the combiner (a symmetric join,
   e.g. liveness Must->Maybe).
* SkipShared - return a pointer-identical subtree unchanged in O(1).
Valid
for an idempotent merge (Combine(a, a) == a), which holds for set union
and
every lattice join. Since dataflow states are path-copied from one
another,
a join's operands usually share most subtrees by pointer, so a join that
   touches only a few keys becomes nearly O(diff).

Wire it into the Clang lifetime-safety analysis (set and map joins) and
the
LiveVariables merge, and add ImmutableMergeBM to track it.

Speedups on the lifetime-safety dataflow benchmark (LoanPropagation
phase):
      pointer cycle in a loop  ~2.6x   (1.59 s  -> 0.61 s)
      CFG merges               ~190x   (1.83 s  -> 9.5 ms)
switch fan-out ~1.9x (LiveOrigins; disjoint states, no skip)
LiveVariables is ~2-3x faster on liveness-heavy inputs and neutral on
typical
code (the join is a small fraction of real-code analysis time).

ImmutableMergeBM confirms the merge beats the add loop for small and
near-identical operands, except for independently-built sets differing
by
exactly one element; when one operand is derived from the other -- the
real
dataflow case -- the pointer-skip makes even that a large win. New
randomized
ADT stress tests check the merge against std::set/std::map oracles for
both
canonicalizing and non-canonicalizing factories.

Assisted by: Claude Opus 4.8

Co-authored-by: Gabor Horvath <[email protected]>
https://invent.kde.org/qt/clang/llvm-project/-/commit/ad3f09c7de3da1f023bc1134eaa33be6d39cc9ca

Git commit b8eebf2704f2ebb6894fd952e4f15fdb62270606 by GitHub (on behalf of h-vetinari) on 21/07/2026 at 11:34..
[libc++][NFC] Re-order availability mapping to `_LIBCPP_INTRODUCED_IN_LLVM_{N}` (#210694)

Noticed that the new additions (from 16f692338cf and 8a531c3608c) were placed
rather randomly. Put the mapping back to reverse chronological order, see 
783fd2f9d.
https://invent.kde.org/qt/clang/llvm-project/-/commit/b8eebf2704f2ebb6894fd952e4f15fdb62270606

Git commit c40a68644c550dcfa3c3d0b560e3aeea1d159d79 by GitHub (on behalf of Michael G. Kazakov) on 21/07/2026 at 11:40..
[libc++] Strip cv-refs in __desugars_to specialization for integral types (#208950)

This PR passes the argument type through `__remove_cvref_t` before
passing to `is_integral`.

Fixes #208236
https://invent.kde.org/qt/clang/llvm-project/-/commit/c40a68644c550dcfa3c3d0b560e3aeea1d159d79

Git commit faaeaf35a50acefd4e25e092e3f720067c40afe3 by GitHub (on behalf of Connector Switch) on 21/07/2026 at 11:41..
[libc++] Implement P0493R5: Atomic minimum/maximum (#180333)

Closes #105418.

Since gcc does not currently support `__atomic_fetch_min/max`, we use a
CAS loop in `atomic_ref` and `support/gcc.h`.

---------

Co-authored-by: Louis Dionne <[email protected]>
https://invent.kde.org/qt/clang/llvm-project/-/commit/faaeaf35a50acefd4e25e092e3f720067c40afe3

Git commit 460778b9d64ed36fd7e80a4cc73ea552aebf016b by GitHub (on behalf of Michael G. Kazakov) on 21/07/2026 at 11:42..
[libc++][pstl] Default implementation of parallel std::adjacent_difference (#207585)

This PR adds a "one-liner" default implementation of parallel
`std::adjacent_difference` on top of parallel binary `std::transform`.

The implementation builds two iterator ranges out of the input one, so
that a zip of these ranges yields adjacent pairs. Then performs a binary
transform to calculate and output the adjacent differences.

Part of https://github.com/llvm/llvm-project/issues/99938
https://invent.kde.org/qt/clang/llvm-project/-/commit/460778b9d64ed36fd7e80a4cc73ea552aebf016b

Git commit d7da964ee1eab426e0d1f617ae2947f4e30d304f by GitHub (on behalf of Balázs Benics) on 21/07/2026 at 11:46..
[analyzer][NFC] Add StackFrame parent-chain range helpers (#210938)

Walking a StackFrame's parent chain was open-coded across the Analysis
library and Static Analyzer as hand-rolled loops of the form `for (const
StackFrame *SF = X; SF; SF = SF->getParent())`.

Add range-based traversal helpers and convert the applicable loops:

* StackFrame::parents() - strict ancestors (excludes *this)
* StackFrame::parentsIncludingSelf() - *this then all ancestors

Both are built on a small forward `parent_iterator` that dereferences to
`const StackFrame &` and advances via getParent(), with a null
past-the-end sentinel.

For the common case of obtaining the current frame from an ExplodedNode
or CheckerContext, add a self-inclusive `stackframes()` convenience on
each that delegates to `getStackFrame()->parentsIncludingSelf()`.

Converted call-sites additionally adopt llvm::any_of / llvm::enumerate /
make_pointer_range where it makes the traversal more declarative. Loops
that stop at a target frame or advance conditionally (i.e. not "walk
until null") are intentionally left as-is.
https://invent.kde.org/qt/clang/llvm-project/-/commit/d7da964ee1eab426e0d1f617ae2947f4e30d304f

Git commit f72f994ad894bf82ab8d12f848f583c5d0cf0048 by GitHub (on behalf of Luke Hutton) on 21/07/2026 at 11:46..
[mlir][ods] Fix string interpolation at end of description (#209744)

Updates the error streaming string logic to handle the case where string
interpolation used at the end of the description. Previously this could
generate malformed code that would not compile e.g.:
```
"' failed to satisfy constraint: another attribute " << reformat(attr)";
```
With this change the above example would now generate:
```
"' failed to satisfy constraint: another attribute " << reformat(attr) << "";
```
https://invent.kde.org/qt/clang/llvm-project/-/commit/f72f994ad894bf82ab8d12f848f583c5d0cf0048

Git commit 3fc3ef399d9972361209917bf26ae9cc7317d3a9 by GitHub (on behalf of Akshay K) on 21/07/2026 at 11:47..
[Clang] Fix assertion failure when classifying a dependent call to a builtin (#210524)

## Summary
Fix an assertion failure when Clang classifies a built-in call with
type-dependent arguments before template instantiation, e.g., while
deducing an `auto` non-type template parameter:

  For example:
  ```cpp
  template <auto> struct S {};

  template <typename T>
  using Alias = S<__builtin_constant_p(T::x)>;
```
```
Assertion failed: (isa<T>(CanonicalType)), function castAs, file
TypeBase.h, line 9349.
 #9  clang::Type::castAs<clang::FunctionType>() const
 #10 clang::CallExpr::getCallReturnType(clang::ASTContext const&) const
 #11 ClassifyInternal(clang::ASTContext&, clang::Expr const*)
#12 clang::Expr::ClassifyImpl(clang::ASTContext&,
clang::SourceLocation*) const
 #13 clang::Sema::DeduceAutoType(...)
 #14 clang::Sema::CheckTemplateArgument(...)
```

## Cause
Built-in references initially have the BuiltinFn placeholder type. For a non-dependent call, `BuildResolvedCallExpr()` applies `CK_BuiltinFnToFnPtr`, converting the callee to its function-pointer type. 

When a call has type-dependent arguments, `BuildCallExpr()` postpones semantic analysis until instantiation. The callee, therefore, retains its BuiltinFn placeholder type. Deducing the auto non-type template parameter classifies the dependent call through `Expr::ClassifyImpl()`. This calls `CallExpr::getCallReturnType()`, which previously did not handle BuiltinFn and attempted to cast the placeholder to FunctionType, triggering an assertion.

The issue also affects ordinary builtins such as `__builtin_ffs` and is not specific to` __builtin_constant_p`.

 ## Fix
Handle `BuiltinFn` alongside the dependent and `Overload` callee cases in `CallExpr::getCallReturnType()` and return `DependentTy`. This matches the type `BuildCallExpr()` gives the `CallExpr` itself, so `getCallReturnType()` and `getType()` now agree on such calls.

Built-in resolution and built-in-specific type checking still occur as usual during template instantiation.

Added coverage for dependent calls and successful instantiation of `__builtin_constant_p` and `__builtin_ffs`,  a non-dependent control case, and getCallReturnType() for a BuiltinFn callee.
https://invent.kde.org/qt/clang/llvm-project/-/commit/3fc3ef399d9972361209917bf26ae9cc7317d3a9

Git commit fe0bc1136dc991486e6a84d6ed034dc3617faaa7 by GitHub (on behalf of Mariusz Sikora) on 21/07/2026 at 12:09..
[NFC][AMDGPU] Add s_wait asynccnt/tensorcnt test for gfx13 (#210916)
https://invent.kde.org/qt/clang/llvm-project/-/commit/fe0bc1136dc991486e6a84d6ed034dc3617faaa7

Git commit f2153eec7aaddd227c303bf0b6e6a8ccb7863857 by GitHub (on behalf of Alexis Engelke) on 21/07/2026 at 12:14..
[Xtensa][NFC] Use compact enum for CPUNames/features (#206954)

Store strings without relocations using compact enums. This reduces the
size of libLLVM.so .data.rel.ro by ~1kiB.
https://invent.kde.org/qt/clang/llvm-project/-/commit/f2153eec7aaddd227c303bf0b6e6a8ccb7863857

Git commit 4d4bf128eb54cdd2ad347507208a202da1f9c172 by GitHub (on behalf of Arseniy Obolenskiy) on 21/07/2026 at 12:29..
[AMDGPU] Reject illegal buffer atomic data widths in SelectionDAG (#210925)

Continuation of the fix introduced in #210366, but this time for
raw/struct buffer atomics instead of image atomics
https://invent.kde.org/qt/clang/llvm-project/-/commit/4d4bf128eb54cdd2ad347507208a202da1f9c172

Git commit a83cc57559428ebd51d51c83db27a9454fbbe114 by GitHub (on behalf of eleviant) on 21/07/2026 at 12:31..
Attempt to fix buildbot failure (#210956)

Value names are discarded by default on build without asserts.
https://invent.kde.org/qt/clang/llvm-project/-/commit/a83cc57559428ebd51d51c83db27a9454fbbe114

Git commit 981735b4df68cab22c5c8309f4fbc6b26aab7258 by GitHub (on behalf of Alexey Bataev) on 21/07/2026 at 12:32..
[SLP]Fix crash on short interleaved gathered-load remainder

A trailing, undersized chunk could keep an InterleaveFactor too
large for it, so RISCVTTIImpl::getInterleavedMemoryOpCost divided
by it and built a zero-element vector type.

Fixes #210849

Reviewers: 

Pull Request: https://github.com/llvm/llvm-project/pull/210965
https://invent.kde.org/qt/clang/llvm-project/-/commit/981735b4df68cab22c5c8309f4fbc6b26aab7258

Git commit 3ed183660093a3d6aa286b5d1339a19c0c834aa1 by GitHub (on behalf of Ömer Sinan Ağacan) on 21/07/2026 at 12:33..
[GlobalISel][AArch64] Add more memcpy and memmove tests (NFC) (#210263)

Test inlined memcpy and memmove operations with multiple loads/stores
with different sizes.

New IR tests added for size 7 to check which one of load/store sequences
we generate:

- 4 + 2 + 1 bytes
- 4 + 4 bytes (4 bytes at offset, 4 bytes at offset + 3)

We also didn't have the `memcpy_inline_...` tests for the
`memmove.inline` intrinsic. I've copied all `memcpy_inline_...` tests
for `memmove.inline`, with the exception of sizes 65, 64, and 63, as I'm
not sure whether they're useful. (the same edge cases are already
checked in tests with sizes 10 and 7)

List of all IR tests added:

- memcpy_7
- memcpy_7_volatile
- memcpy_inline_7
- memcpy_inline_7_volatile
- memmove_7
- memmove_7_volatile
- memmove_inline_0
- memmove_inline_0_volatile
- memmove_inline_7
- memmove_inline_7_volatile
- memmove_inline_10
- memmove_inline_10_volatile
- memmove_inline_300
- memmove_inline_300_volatile
https://invent.kde.org/qt/clang/llvm-project/-/commit/3ed183660093a3d6aa286b5d1339a19c0c834aa1

Git commit 1a11f6ca17790ced1f3108c290e9c48d9bdb55e3 by GitHub (on behalf of Felipe de Azevedo Piovezan) on 21/07/2026 at 12:33..
[lldb] Delete AppleObjCRuntimeV1 (#203190)

This was used in older 32-bit ObjC programs, and it is not used anywhere
by the debugger.
https://invent.kde.org/qt/clang/llvm-project/-/commit/1a11f6ca17790ced1f3108c290e9c48d9bdb55e3

Git commit d0eab040460c110fabc58ab7059bfae732f5c7f4 by Tony Varghese on 21/07/2026 at 12:38..
[PowerPC] Add _Float16 datatype support for Power8+ with -mfloat16 flag

This patch introduces experimental half-precision floating-point (_Float16)
support for PowerPC Power8 and later architectures, enabled via the new
-mfloat16 compiler flag.

Key changes:
- Add -mfloat16 flag to enable half-precision floating-point support
- Register f16 as a legal type using VHFRCRegClass (VSX half-precision registers)
- Implement f16 operations with promotion to f32 for arithmetic operations
- Add hardware conversion support for Power9+ (xscvhpdp/xscvdphp instructions)
- Use libcall conversions for Power8 (__extendhfsf2, __truncsfhf2, etc.)
- Support direct load/store operations for f16 values
- Handle f16 in calling conventions with proper register allocation
- Add comprehensive test coverage for AIX and Linux platforms

The implementation addresses correctness issues from GitHub issues #97975
(intermediate precision) and #97981 (NaN payload corruption) by treating
f16 as a first-class type rather than using lossy conversion functions.

Power9+ uses native hardware instructions for conversions, while Power8
falls back to compiler-rt library functions for type conversions.
https://invent.kde.org/qt/clang/llvm-project/-/commit/d0eab040460c110fabc58ab7059bfae732f5c7f4

Git commit 38263b81abda8e5379eff9badb797483490c019c by Tony Varghese on 21/07/2026 at 12:38..
[PowerPC] Decouple _Float16 ISel and AIX ABI routing from -mfloat16 flag
https://invent.kde.org/qt/clang/llvm-project/-/commit/38263b81abda8e5379eff9badb797483490c019c

Git commit 5536332f68bbeb6f8d84d2182b4282f42582cade by Tony Varghese on 21/07/2026 at 12:38..
[PowerPC] Fix ABI routing, f16 ISel legalization and FP_ROUND/EXTEND lowering.
https://invent.kde.org/qt/clang/llvm-project/-/commit/5536332f68bbeb6f8d84d2182b4282f42582cade

Git commit 34f90bdf07087b92a90d90f8202e1f885fa00331 by Tony Varghese on 21/07/2026 at 13:47..
[PowerPC] Fix f16 BR_CC promotion and update stale AIX TOC test checks.

- Add ISD::BR_CC to F16PromoteOps so half-precision branch conditions
  are promoted to f32 before reaching SelectCC in PPCISelDAGToDAG.
  Without this, fcmp+br on f16 operands crashed with an assertion in
  SelectCC which only handles f32/f64/f128 comparisons.

- Regenerate half-float16-ppc.ll: AIX TOC addressing for constant pool
  entries changed upstream from a single GP-relative ld (ld 3,L..C0(2))
  to an explicit hi/lo addis+ld pair; update the P8-AIX-64 CHECK lines.

- Regenerate soft-promote-half-br-cc.ll: with f16 arguments now arriving
  in FPRs (f1,f2) rather than GPRs (r3,r4) post ABI fix, update all
  CHECK patterns to reflect the FPR-based calling convention.
https://invent.kde.org/qt/clang/llvm-project/-/commit/34f90bdf07087b92a90d90f8202e1f885fa00331

Git commit 638eb376ef0bc5913d716d6779eeef9d90668ba6 by Tony Varghese on 21/07/2026 at 13:47..
[PowerPC] Remove the float16 target feature; make -mfloat16 front-end-only

Delete FeatureFloat16 and the HasFloat16 predicate from PPC.td and stop
emitting +float16 from the driver. -mfloat16 is now marshalled to
LangOpts.PPCFloat16 and forwarded to cc1 directly; its validation (Power8+
requirement, -msoft-float conflict) moves from the driver feature handling
into PPCTargetInfo::adjust().

The flag is purely a source-level admission gate for the _Float16 type.
It produces no LLVM target feature and has no effect on the
target-features attribute, so ABI and code generation depend only on
hardware capability (hasP8Vector() && hasHardFloat()): two translation
units compiled with and without -mfloat16 have identical calling
conventions.
https://invent.kde.org/qt/clang/llvm-project/-/commit/638eb376ef0bc5913d716d6779eeef9d90668ba6

Git commit 8ac25faeb3fd31f46c938671a9f6af5de3bde81a by Tony Varghese on 21/07/2026 at 13:47..
[PowerPC] Fix f16 int conversions, varargs and calling convention

Fix a set of defects in the f16 support found by runtime testing on
Power10 hardware (Linux ELFv2 and AIX) and by review:

- FP_TO_SINT/FP_TO_UINT with an f16 operand are keyed by the legalizer on
  their (legal) integer result type, so the operand was never promoted and
  mis-selected as a double-precision convert, producing silently wrong
  results. Add a DAG combine that extends the operand to f32 first.
- SINT_TO_FP/UINT_TO_FP with an f16 result fell back to a nonexistent
  __floatdihf/__floatundihf libcall for i64 sources. Round through f64
  (fcfid/xscvsxddp then xscvdphp) with a matching combine.
- A variadic f16 argument on ELFv2 hit a BITCAST width assertion in
  LowerCall_64SVR4 when producing the GPR copy of an unnamed FP argument.
  Handle f16 with BITCAST to i16 then ANY_EXTEND, mirroring the f32 path.
- The CC_PPC64_ELF shadow-GPR helper did not count f16, so a scalar f16
  argument failed to reserve its GPR doubleword in the CCState analysis
  used for tail-call and stack-size decisions.
- Map VHFRC to the 8-byte VSX spill slot: the 16-bit value lives in the
  low bits of the 64-bit VSX register, so a full-doubleword store/reload
  is value-preserving and works on both P8 and P9.

Extend half-float16-ppc.ll with int-conversion and variadic coverage, add
f16-elfv2-arg-overflow.ll and P8 coverage to the AIX PSA test, and
regenerate half.ll and pr48519.ll, whose CHECK lines codified the broken
conversion lowering.
https://invent.kde.org/qt/clang/llvm-project/-/commit/8ac25faeb3fd31f46c938671a9f6af5de3bde81a

Git commit 39a774af64c8df9a9ad482af4ba82c97e620c133 by Tony Varghese on 21/07/2026 at 13:47..
[PowerPC] Add _Complex _Float16 and homogeneous-aggregate ABI tests

Pin down two calling-convention decisions requested in review:

- _Complex _Float16 is passed and returned as two scalar half components
  (real, imaginary), each in an FPR, consistent with the scalar rule and
  the psABI treatment of complex types.
- A struct of _Float16 members is not a homogeneous floating-point
  aggregate: it is passed as an integer aggregate (GPRs on ELFv2, byval
  on AIX), contrasted with a float aggregate that does use FPRs. The HFA
  question for _Float16 is deliberately left to the psABI.
https://invent.kde.org/qt/clang/llvm-project/-/commit/39a774af64c8df9a9ad482af4ba82c97e620c133

Git commit ef06063d15e4fbecee1c659aa29ac9a41e580d01 by Tony Varghese on 21/07/2026 at 13:47..
[PowerPC] Add f16 strict-FP support

Registering f16 as a legal type left every STRICT_* opcode at its Legal
default with no selection pattern, so any strict-FP operation on
_Float16 failed to select. Fix the strict path end to end:

- Promote the strict arithmetic, rounding, transcendental and compare
  opcodes (STRICT_FSETCC/STRICT_FSETCCS) to f32 via F16StrictPromoteOps.
- Switch the P9 conversion patterns to any_fpround/any_fpextend so the
  strict nodes select XSCVDPHP/XSCVHPDP directly.
- Make LowerFP_EXTEND strict-aware (thread the chain) and route P9
  f16 -> f128 through xscvhpdp + xscvdpqp instead of regressing to an
  __extendhfsf2 libcall; register STRICT_FP_EXTEND Custom for the f16
  source cases, re-applied after the generic f32/f64 Legal setting that
  would otherwise clobber it.
- Build STRICT_FP_ROUND in the int-to-fp combine with a target rounding
  mode constant, fixing an "Invalid STRICT_FP_ROUND!" assertion on
  strict sitofp/uitofp to f16.
- Suppress register pressure set generation for VHFRC, which shares the
  physical VSX scalar registers.

Add f16-strictfp.ll (P8 and P9) and update the f128-conv.ll ext() checks
for the native P9 sequence.
https://invent.kde.org/qt/clang/llvm-project/-/commit/ef06063d15e4fbecee1c659aa29ac9a41e580d01