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

KDE Git Services - Bulk Change <[email protected]> Thu, 30 Jul 2026 00:14:36 +0000 (UTC)

Newsgroups	gmane.comp.kde.cvs
Message-ID	<[email protected]>

Git repository change summary for qt/clang/llvm-project
Pushed by mirror-service into branch 'upstream/users/arsenm/hexagon/runtime-libcalls-stop-excluding-compiler-rt-generics'.
Changed from 3fbaf8e5518a79ff43881ba797cfad90cf61dcbd to c685715fde218d941a976d3f48bf690e7452c02d
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-project/-/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-project/-/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-project/-/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-project/-/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-project/-/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-project/-/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-project/-/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-project/-/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-project/-/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-project/-/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-project/-/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-project/-/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-project/-/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-project/-/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-project/-/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-project/-/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-project/-/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-project/-/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-project/-/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-project/-/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-project/-/commit/5c57064076a189c457fc0cff463fb2090ccc7347

Git commit 9064e230ab52b82853dbe0d79c8cc75d708a0907 by GitHub (on behalf of Jordan Rupprecht) on 29/07/2026 at 19:24..
Add some bazel libc review coverage (#209789)

This should improve timezone coverage for keeping the bazel build
working due to libc breakages, e.g. #209433 broke things and the bazel
fixer bot sent out #209689. But since it wasn't landed until just
recently, manual fixes were needed for other changes like #209449. This
wouldn't be as bad if the bazel fixer bot could handle layered
breakages.
https://invent.kde.org/qt/clang/llvm-project/-/commit/9064e230ab52b82853dbe0d79c8cc75d708a0907

Git commit 834d585b7c6836996e7fd78ad3fe7675d7c490e2 by GitHub (on behalf of Yingwei Zheng) on 29/07/2026 at 19:25..
[llubi] Fix ptrtoint's return type (#212839)

Closes https://github.com/llvm/llvm-project/issues/212788.
https://invent.kde.org/qt/clang/llvm-project/-/commit/834d585b7c6836996e7fd78ad3fe7675d7c490e2

Git commit 86fb40ddfa3c7cd5c32d758f4b1709d01028a7db by GitHub (on behalf of Kazu Hirata) on 29/07/2026 at 19:51..
[ProfileData] Implement contains in SampleProfileNameTable (NFC) (#211995)

This patch implements contains(StringRef) and contains(uint64_t) in
SampleProfileNameTable and SampleProfileReader to serve symbol
membership queries directly from the reader -- "is this symbol in the
name table?".

Without this patch, users of the sample profile reader, namely
SampleProfileLoader::doInitialization and SampleProfileNameSet, each
construct their own StringSet<> containing all name table entries.
That is, we end up with two instances of StringSet<> with identical
contents. Since these instances hold their own copies of symbol
strings on the heap, both the constructor and destructor take up a
large portion of compilation time.

This patch teaches SampleProfileReader::contains to directly serve
symbol membership queries.

- For EytzingerSampleProfileNameTable, contains performs binary search
directly across the three concatenated Eytzinger table spans
(CSKeys, FlatKeys, and Inlinees) in a cache-friendly manner.

- Other representations of the name table lazily construct an internal
DenseSet on demand.

This patch updates existing customers to call Reader->contains.

RFC:
https://discourse.llvm.org/t/rfc-faster-sample-profile-loading/90957/8

Assisted-by: Antigravity
https://invent.kde.org/qt/clang/llvm-project/-/commit/86fb40ddfa3c7cd5c32d758f4b1709d01028a7db

Git commit 6554a9709a9b9d12ec7eacd7c0a51eac5f94ddff by GitHub (on behalf of Daniil Kovalev) on 29/07/2026 at 19:54..
[PAC][clang][test] Fix incorrect usage of `-NOT` suffix for FileCheck (#212445)

Previously, `-NOT` checks were not doing what was intended: checking
that given strings are not present within the same line where other
patterns are confirmed present by other checks. `-NOT` semantics is
checking pattern absense in between other checks, not total absense.

This patch makes use of `--implicit-check-not` instead for this purpose.
https://invent.kde.org/qt/clang/llvm-project/-/commit/6554a9709a9b9d12ec7eacd7c0a51eac5f94ddff

Git commit 705d0ec6115cef3232eafe6221f42f78e7b884e8 by GitHub (on behalf of Maryam Moghadas) on 29/07/2026 at 19:58..
[SystemZ][z/OS] Implement emitCommonSymbol in MCGOFFStreamer (#210179)

Common globals were not emitted in GOFF object files due to a missing
emitCommonSymbol implementation. This adds the implementation to emit
the required SD/ED/PR ESD records in the GOFF object file.
https://invent.kde.org/qt/clang/llvm-project/-/commit/705d0ec6115cef3232eafe6221f42f78e7b884e8

Git commit ae76985401e3e89e273e43da283f513c7316272d by GitHub (on behalf of Sameer Sahasrabuddhe) on 29/07/2026 at 20:07..
[Docs] don't stylize syntax errors in code blocks (#212698)

When a code block in the documentation contains (almost) pseudocode, the
Pygments parser flags errors and renders them with red-bordered boxes.
This is unnecessarily ugly. We can see examples of this in the LangRef
with LLVM code blocks.

Instead set the style to just render them as plain text. This is still
recognizable as incorrect syntax, but does not distract the reader from
the actual example.

Assisted-by: Claude Opus 4.8
https://invent.kde.org/qt/clang/llvm-project/-/commit/ae76985401e3e89e273e43da283f513c7316272d

Git commit b76b177fc93645cc5a6d2c1e0fc9d941415b1282 by GitHub (on behalf of Alexey Bataev) on 29/07/2026 at 20:20..
[SLP] Gather operands of associative binary chains into one node

Flatten associative single-use chains like ((a+b)+c)+d into one N-ary
tree node instead of nested 2-operand entries, so vectorizable operand
groupings (consecutive loads, broadcasts) spanning the whole chain
aren't hidden by the nesting. The flattened layout is kept only when it
scores better than the natural 2-operand shape. Codegen combines the
columns pairwise, reusing a scalar's IR flags where a combine step
reproduces it exactly and dropping nsw/nuw/nnan/ninf otherwise, since
regrouping can change what may overflow or produce NaN/Inf. Controlled
by the hidden -slp-reassociate-ops flag (default on).

Reviewers: bababuck, RKSimon, hiraditya

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

Git commit 8e564ec0a2215967b1a305d9fd27200a5bece2b0 by GitHub (on behalf of Finn Plummer) on 29/07/2026 at 20:44..
[HLSL] Add in-memory representation of Semantic Signatures (#209907)

Defines the `SemanticSignatureElement` struct in
`llvm/Frontend/HLSL/SemanticSignatures` to represent a semantic
signature in-memory for use during packing and metadata
construction/parsing.

Adds unit testing of the conversion.

Resolves: https://github.com/llvm/llvm-project/issues/204878

Assisted by: Claude Opus 4.8
https://invent.kde.org/qt/clang/llvm-project/-/commit/8e564ec0a2215967b1a305d9fd27200a5bece2b0

Git commit ec27629e6f82e17c5f900f6d16ad1d65766cd4e3 by GitHub (on behalf of Adam Smith) on 29/07/2026 at 21:04..
[CIR] Defer indirect goto resolution to GotoSolver (#206176)

A computed `goto *p` placed inside a nested scope -- an if or a loop
body --
made CIRGen produce invalid IR that the region verifier rejected with
"reference to block defined in another region", aborting the compile.
Regular
`goto` avoids this because CIRGen emits a symbolic
`cir.goto` that references no block and is later resolved into a
`cir.br` by
GotoSolver, which runs after FlattenCFG has merged the nested scopes
into one
region. Indirect goto skipped that indirection: `emitIndirectGotoStmt`
built
a real indirect-branch block during CIRGen and branched to it from
inside the
nested region, and `finishIndirectBranch` wired the `cir.indirect_br`
successors at the end of the function -- both while the scopes were
still
separate regions.

This gives indirect goto the same symbolic treatment. A new terminator,
`cir.indirect_goto`, carries the target address and references no
successor,
so it is valid in any region. GotoSolver now rewrites each one into a
`cir.br` to a single shared block holding the `cir.indirect_br` over
every
address-taken label; running after FlattenCFG, it sees all blocks in one
region, so the cross-region branch can no longer occur. GotoSolver
already
collects the address-taken labels -- from `cir.block_address` ops and
from
block-address attributes in global initializers -- so the CIRGen-side
bookkeeping it supersedes (the lazily-built indirect-goto block, the
per-function target list, and the `CIRGenModule` block-address-to-label
map)
is removed.

An indirect goto that branches out of a scope needing cleanup (a VLA
stack
restore, or a non-trivial destructor on the edge) must run that cleanup
on the
branch, which this does not implement. Rather than emit a branch that
silently skips the cleanup, `emitIndirectGotoStmt` reports it with
`errorNYI`.

With the fix, the `evalloop`, `20041214-1`, and `comp-goto-1` programs
in the
LLVM test-suite go from a CIRGen crash to building and running.
https://invent.kde.org/qt/clang/llvm-project/-/commit/ec27629e6f82e17c5f900f6d16ad1d65766cd4e3

Git commit ce0c2f8e3e66588ac8304fe3f5304652fac877fb by GitHub (on behalf of Deric C.) on 29/07/2026 at 21:16..
[HLSL] Add availability attributes to texture sample methods that require implicit derivatives (#212846)

This PR adds availability attributes to texture sample methods that
require implicit derivatives (fixes
https://github.com/llvm/llvm-project/issues/198885)

To make these availability attributes actually get checked,
`DiagnoseHLSLAvailability::HandleFunctionOrMethodRef` in `SemaHLSL.cpp`
has been changed to check availability attributes regardless of whether
or not a function has a body/definition (fixes
https://github.com/llvm/llvm-project/issues/212842).

Assisted by: Claude Opus 5
https://invent.kde.org/qt/clang/llvm-project/-/commit/ce0c2f8e3e66588ac8304fe3f5304652fac877fb

Git commit 13834ee4dc48abe421c9c13e65b67909f62624a0 by GitHub (on behalf of Andy Kaylor) on 29/07/2026 at 21:17..
[CIR] Introduce fenv attribute for strict fp handling (#211144)

This introduces a new CIR attribute that will be used to describe
floating-point environment assumptions and restrictions, allowing for
general modeling of floating-point environment access. A new interface
is also introduced to simplify handling of default settings when the
attribute or one of its optional components is not present.

This patch adds the attribute and interface to FPBinaryOp,
BinaryFPToFPBuiltinOp, and UnaryFPToFPBuiltin. Support for generating
operations with this attribute and lowering them to the LLVM dialect
will be added in a future change.

Assisted-by: Cursor / claude-opus-4.8
https://invent.kde.org/qt/clang/llvm-project/-/commit/13834ee4dc48abe421c9c13e65b67909f62624a0

Git commit 045fc453c8ccf78b1ccc0bd6b63a719645311cec by GitHub (on behalf of Philip DePetro) on 29/07/2026 at 21:21..
[lldb] Fix flaky test_expr_with_fork_trap by increasing expression timeout (#212574)

The test evaluates an expression that forks a child which returns
normally (triggering SIGTRAP from the JIT wrapper trap at _start). The
parent blocks in waitpid() until the detached child terminates. With the
default 250ms expression timeout, the kernel sometimes doesn't schedule
the detached child fast enough, causing waitpid() to still be blocking
when the timeout fires and the expression gets interrupted.

Set a 5-second expression timeout to give the kernel ample time to
schedule the detached child process.
https://invent.kde.org/qt/clang/llvm-project/-/commit/045fc453c8ccf78b1ccc0bd6b63a719645311cec

Git commit 8a50e79aabbde1b669c939c35b752864d25af2eb by GitHub (on behalf of Erich Keane) on 29/07/2026 at 21:23..
[CIR] Switch FlattenCFGPass to no longer use greedy manager. (#211368)

This showed up doing a self-build of MLIR's Presburger
IntegerRelation.cpp, which is a bit pathalogical. It resulted in us
doing a lot of rewrite patterns during flatten, taking about 20s. After
this patch, we're down to sub-1s spent doing that.

This is because applyOpPatternsGreedily was re-enqueing every child
opops every time we modified anything nearby. This caused us in cases
where there were operations that were visited TONS of times just because
a parent got modified.

This patch replaces this with a very simple inside-out iteration of
these operations. The recent loop-op 'cleanup' flattening modification
necessitates us re-visiting these sometimes (hence the loop).

This patch is effectively 'NFC' other than build time, so there really
isn't a test I could write.

AI: Note: I've used Claude Opus 4.8 to help me with this patch. I've
read/attempted to comprehend as much of this as possible, but I'm still
pretty inexperienced as to how to manage passes/etc. Claude promises me
this is the best way, and I haven't been able to find anything better
grepping around other transformations in other projects, but please
comment if you have a better idea!
https://invent.kde.org/qt/clang/llvm-project/-/commit/8a50e79aabbde1b669c939c35b752864d25af2eb

Git commit 8c4dce6ba0d1eb7d6cc273bdd7496f7bfc4162e3 by GitHub (on behalf of Erich Keane) on 29/07/2026 at 21:23..
[CIR] Implement non-reassoc __arithmetic_fence (#211915)

This builtin is a no-op (just a load/store) if we don't have reassociate
turned on. This patch implements the 'easy' path to unblock libraries
that use this builtin.
https://invent.kde.org/qt/clang/llvm-project/-/commit/8c4dce6ba0d1eb7d6cc273bdd7496f7bfc4162e3

Git commit b9afaf239da61761b870921941bcee1279da0373 by GitHub (on behalf of Matt Arsenault) on 29/07/2026 at 21:25..
clang/AMDGPU: Add missing driver tests for invalid target names (#212451)

Make sure -march and -mcpu both error for nonoffload and for
-Xopenmp-target arguments. Defends against regression I almost
introduced.
https://invent.kde.org/qt/clang/llvm-project/-/commit/b9afaf239da61761b870921941bcee1279da0373

Git commit 485d097213e590c8bb301a22b469a889102ff680 by Matt Arsenault on 29/07/2026 at 21:31..
RuntimeLibcalls: Emit all available impls for a libcall, not just one

The intent is RuntimeLibcalls should represent all functions that are
callable from the module, which may have contextually selectable alternatives.
Previously we had this warning since there was no mechanism to select which
one you want, and as a workaround the library call sets avoided adding the
variants which should nto be selected.

Now targets can use initLibcallLoweringInfo, so remove the warning to unblock
more libcall cleanups. Eventually initLibcallLoweringInfo should also be tablegen
driven.

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

Git commit 40e84f3a8bbeeb16aba8a612bbcd735829cc20bb by Matt Arsenault on 29/07/2026 at 21:31..
MSP430: Mark more generic libgcc functions as available (#210962)

The generic soft-float, conversion, comparison and integer helper
routines (__addsf3, __divli's __divsi3, __ashlsi3, ...) exist in the MSP430
libgcc port alongside the preferred __mspabi_* variants. They were previously
removed to force selection of the __mspabi_* names, back when only one
implementation per libcall could be recorded.

Stop hiding them: only __lshrsi3 stays excluded, since the MSP430 libgcc
port provides the 32-bit logical right shift solely under __mspabi_srll and
never defines a generic __lshrsi3.

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

Git commit ba10a6a1330569f4fd4e4fed1a765f38c2334373 by Matt Arsenault on 29/07/2026 at 21:31..
Revert "MSP430: Mark more generic libgcc functions as available (#210962)"

This reverts commit a7543e65d6b24ff4ea2d8bee1cc676980f4bf76c.
https://invent.kde.org/qt/clang/llvm-project/-/commit/ba10a6a1330569f4fd4e4fed1a765f38c2334373

Git commit 6069ad14689e47816a7d2ab313e2d1c63a2a0cb9 by Matt Arsenault on 29/07/2026 at 21:43..
reduce-comment
https://invent.kde.org/qt/clang/llvm-project/-/commit/6069ad14689e47816a7d2ab313e2d1c63a2a0cb9

Git commit c685715fde218d941a976d3f48bf690e7452c02d by Matt Arsenault on 29/07/2026 at 21:43..
Hexagon: Stop excluding some generic compiler-rt functions from libcalls

RuntimeLibcalls should indicate any function that exists and is callable.
Historically the list of library functions was conflated with the library
functions which should be used, so the library definition was complicated
by excluding the overridden cases. My reading of the compiler-rt sources is
that the generically named functions are built alongside the __hexagon
prefixed variants. e.g., __divsi3 and __hexagon_divsi3 both exist.

It will simplify future libcall work the fewer special case target exclusions
there are, so allow the functions to be defined and apply the selection
preference for the __hexagon prefixed versions in LibcallLoweringInfo.

I do question why compiler-rt is built this way; why doesn't the hexagon
just replace the standard entrypoint names with the target implementations?

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