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

Git repository change summary for qt/clang/llvm
Pushed by mirror-service into branch 'upstream/users/arsenm/runtime-libcalls/fcmp-3way-compare-aeabi'.
Changed from 63db93737fc8c37aceee8714f09b659361c87be2 to d77892c03087d3120bc6a3faed9a31cefd949504
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 32eae3a39471911888ba50bf03379450b4d96e3e by GitHub (on behalf of Eugene Epshteyn) on 29/07/2026 at 17:21..
[flang] Statement function dummy names do not clash with host or unreferenced global names (#212396)

The check added for F2023 19.4 p2 (statement function dummy argument
name may be the same as an accessible name only if that name is a scalar
variable) looked the name up through the whole host scope chain and,
failing that, in the global scope. Both lookups overshoot what is
"accessible" in the scoping unit:

* Per F2023 19.5.1.4 p2 item (11), the appearance of a name as a
dummy-arg-name in a stmt-function-stmt makes any host entity of that
name inaccessible by host association throughout the scoping unit, so a
host entity can never conflict with the dummy.

* A global entity to which the scoping unit makes no reference at all is
not accessible in it; otherwise conformance would depend on whether
unrelated program units happen to be compiled in the same file.

This caused bogus errors on conforming code such as
```
  program p
    logical, external :: x
  contains
    subroutine s
      real :: f
      f(x) = x * x  ! 'x' is an implicitly typed real dummy here
    end
  end
```
where the dummy 'x' must be implicitly typed real (both NAG and gfortran
accept this and type it that way; flang already typed it correctly, but
rejected the program).

Restrict the lookup to names made visible by the scoping unit itself
(declared, referenced, or USE-associated there), matching the lookup
HandleStmtFunction already uses to type the dummies.

Assisted-by: AI
https://invent.kde.org/qt/clang/llvm/-/commit/32eae3a39471911888ba50bf03379450b4d96e3e

Git commit 13ac5c62ce5aab0395849fec322eb402ab784b76 by GitHub (on behalf of Thirumalai Shaktivel) on 29/07/2026 at 17:26..
[flang][openmp] Add semantic checks in THREADPRIVATE/DECLARE TARGET (#209084)

The problem is that the automatic object was used as the
threadprivate argument.

Solution:
From the documentation (J3/24-007):
> C814 An automatic data object shall not have the SAVE attribute.
> C862 The SAVE attribute shall not be specified for a dummy argument,
>      a function result, an automatic data object, or an object
>      that is in a common block.

The bare SAVE statement makes any valid local variables tagged
with the SAVE attribute. As the restriction mentioned above, the
automatic object cannot have a SAVE attribute and shall not be
used as the THREADPRIVATE argument. This patch adds semantic
checks for dummy arguments, function results, and automatic data
objects in both THREADPRIVATE and DECLARE TARGET directives.

[flang][OpenMP] Fix DECLARE TARGET to reject distinct result name

When a function uses a distinct result name (e.g. result(res)),
DECLARE TARGET(res) was not diagnosed because ResolveOmpDesignator
rebound it to the procedure, skipping the IsFunctionResult check.
https://invent.kde.org/qt/clang/llvm/-/commit/13ac5c62ce5aab0395849fec322eb402ab784b76

Git commit 13310e947e510320bfde9a800a6292265f630b97 by GitHub (on behalf of Navaneeth Shanmugasundaram) on 29/07/2026 at 17:44..
[GitHub] Fix authentication for release workflow git push (#212634)

Update the push URL format to use GitHub's required authentication
format with the 'x-access-token' prefix. GitHub now requires:
  https://x-access-token:{token}@github.com/{repo}

instead of the deprecated format:
  https://{token}@github.com/{repo}

Without this change, the release workflow fails when attempting to push
branches with the error:
  fatal: could not read Password for 'https://***@github.com':
  No such device or address

This occurs because Git attempts to prompt for credentials in the
non-interactive GitHub Actions environment when the token format is not
recognized.

Fixes the /cherry-pick command in the issue-release-workflow.

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

Git commit b979a119274a13fdee769478702148006219fc5b by GitHub (on behalf of Adam Smith) on 29/07/2026 at 17:51..
[CIR] Lower indirect calls in CallConvLowering (#211636)

Indirect calls were unsupported by CallConvLowering.  `rewriteCallSite` bailed
with "indirect call not yet implemented", and the pass driver rejected any
module that both needed call-site rewriting and contained an indirect call.  A
function pointer whose signature required ABI reshaping (a by-value struct
argument, or an sret return) could not be compiled at all, even though a
direct call to the same signature lowered fine.

The callee is opaque, but its type is a pointer to a `FuncType` that carries the
full signature.  Classification is now driven from that pointee signature
through the same LLVM ABI path as the direct case: `classifyX86_64Function` is
split into `classifyX86_64Signature`, taking a return type, an argument
`TypeRange`, and an `emitError` callback.  The driver collects indirect calls,
classifies each callee signature (x86_64, or the test target used by the pass
tests), and runs `rewriteCallSite`.  `prependIndirectCallee` re-adds the callee
as operand 0, bitcasting the function pointer to the coerced signature when it
differs so the rebuilt call matches its reshaped return.

The `classification-attr` driver mode injects a per-function classification
that cannot describe a callee resolved at run time, so an indirect call is a
diagnosed error there rather than being left silently unrewritten while direct
calls are coerced.
https://invent.kde.org/qt/clang/llvm/-/commit/b979a119274a13fdee769478702148006219fc5b

Git commit f958a55f66a062b4c005015b691a949deb24e237 by GitHub (on behalf of Jonas Devlieghere) on 29/07/2026 at 17:52..
[lldb-mcp] Add --help and --version (#212680)

lldb-mcp accepted no arguments at all, so --help and --version fell
through to the protocol loop and blocked reading stdin, and a mistyped
flag was silently ignored while the tool waited for MCP traffic. Handle
both flags and reject anything else with a usage message.
https://invent.kde.org/qt/clang/llvm/-/commit/f958a55f66a062b4c005015b691a949deb24e237

Git commit 130dccc2c3192d9f49c2e85bcd047ed67a9fa9e1 by GitHub (on behalf of Nikita Taranov) on 29/07/2026 at 17:52..
[XRay][test] Raise fdr-mode.cpp unwrite threshold to deflake it (#211595)

It was observed failing on `sanitizer-aarch64-linux` ([build
40750](https://lab.llvm.org/buildbot/#/builders/51/builds/40750)).

The failure is in the `UNWRITE` run
(`XRAY_FDR_OPTIONS="func_duration_threshold_us=5000"`), which asserts
that every short function record is "unwritten" (rewound) except
arg1-logging records. In the failing output an `fA()` enter/exit pair
survived:

```
<stdin>:9:  - { func-id: 3, function: 'fA()', cpu: 0, thread: 1909237, kind: function-enter, tsc: 1784775492023431847 }
<stdin>:10: - { func-id: 3, function: 'fA()', cpu: 0, thread: 1909237, kind: function-exit,  tsc: 1784775492029462345 }
<stdin>:11: - { func-id: 4, function: 'fArg(int)', args: [ 1 ], ..., kind: function-enter-arg, ... }
```

so `UNWRITE-NEXT` (and `UNWRITE-NOT: function-enter`) no longer hold.

FDR mode only rewinds a function's enter record when its exit lands
within the threshold (`XRayFDRController::functionExit`: `TSC -
LastFunctionEntryTSC < CycleThreshold`).

```
1784775492029462345 - 1784775492023431847 = 6,030,498 cycles / 1 GHz = 6.03 ms  >  5 ms threshold
```

i.e. the thread was preempted for ~6 ms mid-function, so the record was
(correctly, by the runtime's own rule) not unwritten.

The proposed fix is to raise the `UNWRITE` run's
`func_duration_threshold_us` from `5000` to `100000`, so realistic
scheduling jitter cannot push a short function over the threshold. This
mirrors the accepted fix for the sibling test in
[PR #186611](https://github.com/llvm/llvm-project/pull/186611)
(`basic-filtering.cpp`), which flaked the same way.
https://invent.kde.org/qt/clang/llvm/-/commit/130dccc2c3192d9f49c2e85bcd047ed67a9fa9e1

Git commit 125080fbaa17ddab3313f580a2d2ab686a03be55 by GitHub (on behalf of Steven Wu) on 29/07/2026 at 17:56..
[Darwin][tests] Partially restore some of the change in #212329 (#212826)

Restore the fallback path for ld-classic in #212329 to fix some of the
failing CI jobs due to some Xcode releases doesn't have the new linker
that supports `-save-temps` flag. Restore the logic so that `ld-classic`
is preferred over `ld` but no longer requires ld64/ld-classic.

In legacy releases only has ld64, ld64 is used. In latest releases where
ld64 is removed, new linker is feature completed and fully compatible
with ld64. During the transition period where ld64 is shipped as
ld-classic, prefer ld64 since new linker might not be feature complete.

rdar://183454376
https://invent.kde.org/qt/clang/llvm/-/commit/125080fbaa17ddab3313f580a2d2ab686a03be55

Git commit aa924278efbd4f76329bb95ebd33fd3e445d4ff4 by GitHub (on behalf of Lucas Mellone) on 29/07/2026 at 17:57..
[libc++][math] Add missing `constexpr since C++23` comment for `signbit` (#212458)

Adds the missing `// constexpr since C++23` for `std::signbit` in the
synopsis comments of `<cmath>`.
Follows-up: https://github.com/llvm/llvm-project/pull/105946.
https://invent.kde.org/qt/clang/llvm/-/commit/aa924278efbd4f76329bb95ebd33fd3e445d4ff4

Git commit d6a165836cc7bc64bda1ceab22937839cb88d5cc by GitHub (on behalf of Roland McGrath) on 29/07/2026 at 17:59..
[CMake][Fuchsia] Compile runtimes with -ffuchsia-api-level (#211753)

Use the supplied Fuchsia SDK's version_history.json to deduce the
oldest API level still supported, and target that for toolchain
runtimes so they'll be runtime-compatible when linked into user
programs that target any SDK-supported API level.
https://invent.kde.org/qt/clang/llvm/-/commit/d6a165836cc7bc64bda1ceab22937839cb88d5cc

Git commit 0e351245ff0cf7a824207658c189ef099b3aaaab by GitHub (on behalf of Ebuka Ezike) on 29/07/2026 at 18:02..
[lldb-dap] Migrate unknownRequest, subtleFrames and longpath (#211627)

Migrated tests:
- TestDAP_unknownRequest.py
- TestDAP_subtleFrames.py
- TestDAP_launch_longPath.py
https://invent.kde.org/qt/clang/llvm/-/commit/0e351245ff0cf7a824207658c189ef099b3aaaab

Git commit 8d404384dd842d43362732a11b233ee3d6ead023 by GitHub (on behalf of Jackson Stogel) on 29/07/2026 at 18:07..
[libc][realpath] Follow symlinks (#212164)

This commit updates realpath to call `readlinkat` on symlinks during
path resolution.

Some notes on implementation:
- `PendingPath` uses a `cpp::string` to store unprocessed path
components. This could be more efficient by using a `PATH_MAX` buffer
and storing the path at the end of the buffer, which would allow for
easy prepending. However, using a `cpp::string` avoids the pointer
arithmetic and memory management that would involve.
- This PR implements `cpp::string::replace` to avoid pointer arithmetic
inside `realpath`. This should hopefully not be too inefficient, since
`prepend` reuses space from processed path components there's enough
room, there certainly exist some bad inputs that would cause many
`memmove` operations.
https://invent.kde.org/qt/clang/llvm/-/commit/8d404384dd842d43362732a11b233ee3d6ead023

Git commit 7bed6591be3191446ec2cf92ef247487fff03a84 by GitHub (on behalf of Diego Novillo) on 29/07/2026 at 18:09..
[SPIRV] Emit NonSemantic DebugTypeComposite and DebugTypeMember. (#211638)

This PR adds `DebugTypeComposite` (opcode 10) and `DebugTypeMember`
(opcode 11):

1. `partitionTypes` clusters `DICompositeType` with
`DW_TAG_structure_type`, `DW_TAG_class_type`, or `DW_TAG_union_type`.
2. Each composite emits one `DebugTypeMember` per `DW_TAG_member`, then
a `DebugTypeComposite`. Members precede the composite.
3. Tag maps class, structure, and union to 0, 1, and 2. A forward
declaration emits `DebugInfoNone` for Size and no members.
4. A member whose type is not in `DebugTypeRegs` is skipped.

`DebugTypeMember` has no Parent operand, per the spec. Only the
composite references its members.

Tests in `llvm/test/CodeGen/SPIRV/debug-info/`:

1. `debug-type-composite.ll`: a struct with two members and a forward
declaration.
2. `debug-type-composite-skip-member-not-in-regs.ll`: a member whose
type is a pointer with no DWARF address space, exercising the skip.

`debug-global-variable-skip-type-not-in-regs.ll` and
`debug-global-variable-static-member.ll` assumed composites and members
are never emitted. Both now use a no-address-space pointer to avoid
disabling the existing test.
https://invent.kde.org/qt/clang/llvm/-/commit/7bed6591be3191446ec2cf92ef247487fff03a84

Git commit a42bed3f72c427dcd023aae169bec9305ec29ed6 by GitHub (on behalf of fineg74) on 29/07/2026 at 18:10..
[OFFLOAD] Add JIT support for SPIRV backend (#212823)

This PR adds support for SPIRV to plugins JIT. It is required in cases
when kernel is supplied in bitcode format for spirv triple.
https://invent.kde.org/qt/clang/llvm/-/commit/a42bed3f72c427dcd023aae169bec9305ec29ed6

Git commit 16f116f476c248c345fd8ffe4b3e863f2700161f by GitHub (on behalf of Jonas Devlieghere) on 29/07/2026 at 18:12..
[lldb] Reply to malformed requests and use JSON-RPC error codes (#212678)

The transport dropped a message that failed to parse: it logged the
error and returned, so a peer waiting on that request hung forever and
every message already buffered behind it was discarded. Keep going after
a failed parse, and add ReplyWithParseError so a message that is valid
JSON but not a valid request is answered against its own id. Unparseable
JSON still gets no reply, since it carries no id and JSON-RPC forbids
inventing one.

Method-not-found was raised with createStringError, which converts
through inconvertibleErrorCode() to -32603, so clients could not tell a
misspelled method from a server fault. Use the MethodNotFound error,
which already carries -32601, and give InvalidParams the -32602 code it
was missing.
https://invent.kde.org/qt/clang/llvm/-/commit/16f116f476c248c345fd8ffe4b3e863f2700161f

Git commit 58a93a1eec10d30dfa358afda73f402fb308a5e4 by GitHub (on behalf of Jonas Devlieghere) on 29/07/2026 at 18:13..
[lldb-mcp] Run managed debug sessions synchronously (#212681)

A debugger created for an MCP session has no event loop to service
asynchronous stops, so a resume returned before the process stopped and
every subsequent command failed against a still-running process. That
made breakpoint debugging unusable: `run` reported only the launch, and
`bt` that followed it errored out. Create these debuggers in synchronous
mode, as lldb-dap does.
https://invent.kde.org/qt/clang/llvm/-/commit/58a93a1eec10d30dfa358afda73f402fb308a5e4

Git commit 33c7ef4a631db53440f569f048660474e0a46bd6 by GitHub (on behalf of 陈子昂) on 29/07/2026 at 18:24..
[Clang][RISCV] Add packed pair byte intrinsics (#212589)

Add the 32-bit byte forms and the 64-bit byte/halfword forms of the
P-extension packed pair intrinsics to riscv_packed_simd.h using generic
shufflevector IR.

Extend the existing packed pair shuffle lowering to recognize the mixed
even/odd forms and select ppaireo/ppairoe in addition to ppaire/ppairo.

Add Clang CodeGen, LLVM CodeGen, and intrinsic header tests for the new
forms.
https://invent.kde.org/qt/clang/llvm/-/commit/33c7ef4a631db53440f569f048660474e0a46bd6

Git commit 0475ef459c0bf24d79330372fef29a4aaf68c87d by GitHub (on behalf of Kewen Meng) on 29/07/2026 at 18:28..
Revert "[OpenMP] Restore loop variable values after loop-tranformation constructs." (#212832)

Reverts llvm/llvm-project#208533

PR breaks several bots. Revert to unblock. 

https://lab.llvm.org/buildbot/#/builders/10/builds/32840
https://lab.llvm.org/buildbot/#/builders/88/builds/24941
https://lab.llvm.org/buildbot/#/builders/225/builds/13974
https://invent.kde.org/qt/clang/llvm/-/commit/0475ef459c0bf24d79330372fef29a4aaf68c87d

Git commit bacfe2950f8218268fcc0a8765644ea0c15f0360 by GitHub (on behalf of Mikhail Romanov) on 29/07/2026 at 18:34..
[MLIR] Fix transform.apply_patterns with apply_cse option (#212818)

This patch fixes a crash in `transform.apply_patterns` when `apply_cse`
is enabled and the target operation does not have the
`IsolatedFromAbove` trait.

For non-`IsolatedFromAbove` targets, `transform.apply_patterns` cannot
apply patterns directly to the target operation. Instead, it collects
the operations within the target into a worklist and passes that
worklist to `applyOpPatternsGreedily`. When `apply_cse` is enabled,
pattern application and CSE are performed repeatedly until a fixpoint is
reached.

Previously, the worklist was collected only once before entering the
fixpoint loop. However, pattern application may erase operations from
the IR, leaving stale pointers in the cached worklist. Reusing this
worklist in subsequent iterations may therefore result in a crash.

This patch rebuilds the worklist at the beginning of each iteration,
ensuring that it always reflects the current IR state.

A representative reproducer is shown below:
```llvm
module attributes {transform.with_named_sequence} {
  func.func @test(%A: tensor<128x256xf32>,
                  %B: tensor<256x512xf32>,
                  %C: tensor<128x512xf32>) -> tensor<128x512xf32> {
    %res = linalg.matmul
        ins(%A, %B : tensor<128x256xf32>, tensor<256x512xf32>)
        outs(%C : tensor<128x512xf32>) -> tensor<128x512xf32>
    return %res : tensor<128x512xf32>
  }

  transform.named_sequence @__transform_main(%root: !transform.any_op) {
    %matmul = transform.structured.match
        ops{["linalg.matmul"]}
        in %root
        : (!transform.any_op) -> !transform.any_op

    %tiled, %loops:3 =
        transform.structured.tile_using_for %matmul
            tile_sizes [4, 4, 4]
        : (!transform.any_op)
          -> (!transform.any_op,
              !transform.any_op,
              !transform.any_op,
              !transform.any_op)

    transform.structured.vectorize %tiled : !transform.any_op

    transform.apply_patterns to %loops#0 {
      transform.apply_patterns.canonicalization
    } {apply_cse} : !transform.any_op

    transform.yield
  }
}
```

Here, `transform.apply_patterns` is applied to the `scf.for` loop
produced by tiling, which is not `IsolatedFromAbove`. Running `mlir-opt
--transform-interpreter` on this example crashes before this change and
completes successfully with this patch.

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

Git commit a9749e8e26273338c6c115c0d70c538fa30bba85 by GitHub (on behalf of Andre Kuhlenschmidt) on 29/07/2026 at 18:42..
[flang][semantics] Accept BOZ initializers for C enum values (#211904)

Fortran 2023 7.6.1 errata f23/013 changes R762 so an interoperable
enumerator may be a named-constant initialized by a
boz-literal-constant, and specifies the value as
INT(boz-literal-constant, C_INT).

Handle that named-constant restriction directly in enum resolution while
preserving the usual scalar integer expression checks for non-enumerator
contexts. This mirrors the general named-constant initializer path,
which already converts BOZ values through the declared type before
folding.
https://invent.kde.org/qt/clang/llvm/-/commit/a9749e8e26273338c6c115c0d70c538fa30bba85

Git commit 499db7987c994cf9a7742928bfd88ceb7bd12204 by GitHub (on behalf of Alexis Engelke) on 29/07/2026 at 18:43..
Revert "[Clang] Don't build static analyzer if disabled" (#212836)

Breaks unusual build configs where clang-tidy static analyzer is enabled
while clang static analyzer is disabled.

Reverts llvm/llvm-project#212024
https://invent.kde.org/qt/clang/llvm/-/commit/499db7987c994cf9a7742928bfd88ceb7bd12204

Git commit 5c57064076a189c457fc0cff463fb2090ccc7347 by GitHub (on behalf of Rafael Auler) on 29/07/2026 at 18:50..
[BOLT] Stop materializing .dwo DIE vectors early in the pipeline (#207292)

Summary: preprocessDWODebugInfo() eagerly force-extracted every .dwo
compile unit's DIE tree (getNonSkeletonUnitDIE(false)) very early in
BOLT pipeline, way before DWARFRewriter kicked in. Those vectors then
sit in memory throughout the entire rewrite pipeline, directly
contributing to BOLT's RSS peak. I did a fair amount of digging and
didn't find any reason as to why we need to keep all DIEs of DWO CU
materialized at all, since DWARFRewriter won't even read this vector
(the #197359 concurrency fix did use that, but that is unnecessary). The
problem is that these DIE trees are a massive contribution to RSS when
processing large binaries where we have 10s of K of dwos, storing
complete trees for each processed dwo.

This diff changes the #197359 concurrency fix to not rely on the DIE
sibling/children structure. It parses DWP type units selectively per
compile unit (DIEBuilder::buildDWPTypeUnitsForUnit ->
collectReferencedTypeSignatures) by finding the DW_FORM_ref_sig8
references in a unit's DIEs to decide which type units belong in that
unit's output .dwo. That walk previously used DWARFDie::children(),
which requires the unit's full DIE vector. Here we rewrite the walk to
stream the unit's DIEs one at a time with
DWARFDebugInfoEntry::extractFast (the same technique already used by
DIEBuilder::constructFromUnit and DWARFRewriter::partitionCUs), reading
DW_FORM_ref_sig8 attributes off a single reusable transient entry. The
tree structure is irrelevant -- every DIE in the unit is visited
regardless -- so no DIE vector is
built. collectReferencedTypeSignatures now takes a DWARFUnit& instead of
a DWARFDie.

With the walk self-sufficient:
- preprocessDWODebugInfo() now extracts only the .dwo CU DIE
(getNonSkeletonUnitDIE(true)); nothing reads the full array off it
anymore (constructFromUnit and the signature walk both stream).
- BinaryContext::collectDebugScopeBoundaries() drops its split-DWARF
fast-path, which called DWARFUnit::dies() (= full extraction); DWO units
are now streamed like monolithic ones.

The result is that .dwo DIE vectors are never materialized during BOLT
processing.

Expected to be a ~10% RSS win on large split-dwarf binaries.

Depends on #207291
https://invent.kde.org/qt/clang/llvm/-/commit/5c57064076a189c457fc0cff463fb2090ccc7347

Git commit d77892c03087d3120bc6a3faed9a31cefd949504 by Matt Arsenault on 29/07/2026 at 19:25..
RuntimeLibcalls: Split soft-float three-way compares into distinct libcall kinds

Soft-float compares come in two flavors. ARM AEABI (__aeabi_dcmpeq) and VFP
(__eqdf2vfp) return a simple 0/1 boolean and use the existing O*_F* / UO_F*
libcalls. The libgcc/compiler-rt helpers (__eqdf2, __ltdf2, ...) return a
three-way -1/0/1, which the legalizer needs to insert the appropriate compare
against.

The three-way helpers previously masqueraded as O*_F* implementations, with the
condition code recovered from a hardcoded switch. Model them instead as distinct
operations. The legalizer then reasons about how to make use of the call result
based on which flavor of operation is available, rather than special casing what
the specific implementation is.

This leaves the mspabi cases for a later cleanup, because it's 3-way usage is
slightly different from the ARM case.

Co-authored-by: Claude (Opus 4.8) <[email protected]>
https://invent.kde.org/qt/clang/llvm/-/commit/d77892c03087d3120bc6a3faed9a31cefd949504