[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/lukel97/loop-vectorize/simplifyRecipes-worklist'.
Changed from 97e96c19d12a01153cce0b48b1c5f5b4d29c3106 to 64fa13322ac9fe9f3a3f4d78c22520031fba25c0
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 73817e6a9279833e53fb9ccca3158ed987c4ad61 by GitHub (on behalf of Heejin Ahn) on 04/08/2026 at 05:19..
[WebAssembly] Add funclet bundle to thread local wrapper calls (#213826)

When accessing a thread local variable, Clang generates a thread local
wrapper function that checks if the variable has been initialized, and
if it isn't, initializes it. This is a function call, so if this is
within a funclet (i.e., within a `catchpad` or `cleanuppad`), it needs
the funclet bundle argument, which was missing before. If it lacks a
funclet argument, it will be considered invalid and removed in
WinEHPrepare.

Fixes https://github.com/emscripten-core/emscripten/issues/27448.
https://invent.kde.org/qt/clang/llvm-project/-/commit/73817e6a9279833e53fb9ccca3158ed987c4ad61

Git commit ecd6a18e03d37c2bcaf9893d9ae2698b66ac2e83 by GitHub (on behalf of Jianhui Li) on 04/08/2026 at 05:35..
[mlir][xegpu] Support batched matmul in    VectorToXeGPU ContractionLowering (#211947)

Generalizes ContractionLowering in
mlir/lib/Conversion/VectorToXeGPU/VectorToXeGPU.cpp so that (batched)
N-D vector.contract ops lower to xegpu.dpas, not just plain 2D matmuls.

---------

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

Git commit 8b18aa0b1ec2de76d47748a4d13c4de02b4d8580 by GitHub (on behalf of Garvit Gupta) on 04/08/2026 at 05:43..
[RISCV] Reduce spill/reload pairs when Xqcilo extension is enabled (#212807)

[RISCV] Reduce spill/reload pairs when Xqcilo extension is enabled

Currently, `SelectAddrRegImm26` calls `SelectAddrFrameIndex` first,
causing bare frame-index loads (offset 0) to select 48-bit loads/stores at
ISel. Due to `AddedComplexity=2` on the QC48LdPat patterns, the wide
opcode won over the standard LW/SW even though the resolved frame offset
typically fits simm12.

This led to more spills and reloads in functions which are under high
register pressure because 48-bit loads and stores are not marked easily
rematerializable. Also, simply adding 48-bit loads and stores to
`isLoadFromStackSlot/isStoreToStackSlot` doesn't solve the regression
for the multi call case and only by making Isel produce the plain
32/64-bit loads and store opcodes as the baseline does RA behave
identically.

Therefor this PR fixes the issue by:

-Remove the `SelectAddrFrameIndex` call from SelectAddrRegImm26. Bare frame
indices now fall through to standard LW/SW selection at ISel, where RA
recognizes them as rematerializable stack loads.

-Add post-RA promotion in `eliminateFrameIndex`: when a plain LW/SW has a
resolved frame offset that exceeds simm12, promote the opcode to
the corresponding 48-bit load/store opcode and fold the 26-bit offset
directly. This preserves the intended large-offset optimization
without affecting RA decisions.

This solves the code size regression in high register pressure function
introduced by PR #209315

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

Git commit 7bf32f63ee90b964a49212efd09ebd299d6718bb by GitHub (on behalf of Michael G. Kazakov) on 04/08/2026 at 05:58..
[libc++][pstl] Implementation of parallel std::reverse() based on parallel for_each (#213487)

This PR implements a parallel version of `std::reverse()` based on the
parallel `__for_each()`.

The implementation walks the first half of the range in chunks, each
chunk is swapped with its mirrored counterpart via `std::swap_ranges()`
and `std::reverse_iterator<>`:
```c++
// Perform a chunked for_each on the first half of the range.
return __cpu_traits<_Backend>::__for_each(
    first, first + (last - first) / 2, [first, last](ForwardIterator i, ForwardIterator j) {
    // Derive the last position of the mirrored range.
    ForwardIterator mirror_last = last - (i - first);
    // Swap the elements in the range of the first half with their mirrored counterparts in the second half.
    std::swap_ranges(i, j, std::reverse_iterator<ForwardIterator>(mirror_last));
});
```

Included tests check that:
- Semantics of the function is correct.
- The function correctly SFINAE out when the first argument is not an
execution policy.
- The `noexcept` policy is followed.
- `static_assert` verifies iterators' categories.

Part of #99938.
https://invent.kde.org/qt/clang/llvm-project/-/commit/7bf32f63ee90b964a49212efd09ebd299d6718bb

Git commit b8fd0c1cbb1867ddf74eb80ced58c5d289a56321 by GitHub (on behalf of Michael G. Kazakov) on 04/08/2026 at 06:00..
[libc++][pstl] Implementation of parallel std::is_sorted_until() based on std::adjacent_find() (#213445)

This PR adds implementation of a parallel `std::is_sorted_until()` based
on the parallel `std::adjacent_find()` and rebases the parallel
`std::is_sorted()` onto `std::is_sorted_until()`.

The implementation is effectively a one-liner:
```c++
// Find the first pair of adjacent elements that are not in sorted order,
// i.e. comp(rhs, lhs) is true.
auto res = AdjacentFind()(policy, std::move(first), last, [&](Ref lhs, Ref rhs) {
    return comp(rhs, lhs);
});
```

Included tests check that:
- Semantics of the iterator-only version is correct.
- Semantics of the predicated version is correct.
- The functions correctly SFINAE out when the first argument is not an
execution policy.
- The `noexcept` policy is followed.
- The `nodiscard` policy is followed.
- `static_assert` verifies iterators' categories.

Part of #99938.
https://invent.kde.org/qt/clang/llvm-project/-/commit/b8fd0c1cbb1867ddf74eb80ced58c5d289a56321

Git commit a2a70991059b04c8cfc8b4c3715361cf0024d6af by GitHub (on behalf of Matt Arsenault) on 04/08/2026 at 06:01..
AMDGPU: Validate generic processor features in TargetParser emitter (#213774)

Perform some initial validation that the feature set of generic
targets is consistent with the set of covered targets. For now, this
only performs this validation for the subset of frontend exported
features, so is limited to catching missed builtin support. In the future
arbitrary features should be validated, but this is complicated by workaround 
features and size features which need to clamp to the common minimum.

Co-authored-by: Claude (Claude-Opus-4.8)
https://invent.kde.org/qt/clang/llvm-project/-/commit/a2a70991059b04c8cfc8b4c3715361cf0024d6af

Git commit 7ea6d45feaed43266ece53df274aaf6b53340238 by GitHub (on behalf of Pavel Labath) on 04/08/2026 at 06:11..
[libc] Add a C unit test framework wrapper and convert existing tests (#213657)

This removes the dependency on the host C library (hermetic tests),
makes sure the tests actually do something in release builds (where
assert() is a noop), and makes better and more consistent failure
messages.

This is just a thin wrapper over the existing framework which repackages
the C++ interface into something consumable by C code. I tried to keep
the interface consistent, but of course, many of the framework features
are C++ only. Registering more than one test function was tricky, so the
framework currently supports only one.

The main trick here was getting the static library linker to extract
LibcCTest.cpp.o from libLibcTest.unit.a. Since C test cases don't
instantiate static CTest objects in their own translation unit like C++
tests do (they cannot do that portably), nothing in the object file
referenced LibcCTest.cpp. I made this work by introducing
libc_c_test_anchor() and calling it explicitly inside the generated
libc_c_test_run() function.
https://invent.kde.org/qt/clang/llvm-project/-/commit/7ea6d45feaed43266ece53df274aaf6b53340238

Git commit 4616e9bbb9774bd0662ac095359a5d362f449819 by GitHub (on behalf of Pavel Labath) on 04/08/2026 at 06:14..
[libc] Add optional::value_or and clean up if_nameindex_test TODOs (#213682)

I went through the TODOs in if_nameindex_test.cpp:
- string::operator+=(string_view) was already present in string.h (added
in #210895), so I removed the append_bytes helper and switched to
operator+= directly.
- I added value_or (const & and && overloads) to cpp::optional and added
a test suite for it in optional_test.cpp.
- I replaced pop_front_or with pop_front returning optional<T> and
inlined the .value_or(...) calls in the fake network policy.
- Updated the CMake dependencies to account for the new optional usage.

Assisted by Gemini.
https://invent.kde.org/qt/clang/llvm-project/-/commit/4616e9bbb9774bd0662ac095359a5d362f449819

Git commit 2b3dd2dc32be01ebb74c15d919822538db0292db by GitHub (on behalf of Antonio Frighetto) on 04/08/2026 at 06:47..
[GlobalsAA] Handle self-referencing stores in `AnalyzeUsesOfPointer` (#213631)

Correctly recognize that a global address does escape when it is stored
into itself. Such globals were previously incorrectly marked as
non-address-taken.

Fixes: https://github.com/llvm/llvm-project/issues/213232.
https://invent.kde.org/qt/clang/llvm-project/-/commit/2b3dd2dc32be01ebb74c15d919822538db0292db

Git commit 3a6ae9bcb9c76bd5da5fbd81e055be907339f513 by GitHub (on behalf of ABWI-Y) on 04/08/2026 at 06:49..
[X86][AsmParser] Fix compiler crash on division by zero in MS inline asm (#213539)

This fixes issue #213415. If a user writes something like '1 / 0' or '1
% 0' in assembly, the compiler will now show a normal error message
instead of crashing completely.

Fixes #213415

Co-authored-by: 陈纪元 <[email protected]>
https://invent.kde.org/qt/clang/llvm-project/-/commit/3a6ae9bcb9c76bd5da5fbd81e055be907339f513

Git commit 1fef59b860b4bba1cf4593563c25717a34cef2e4 by GitHub (on behalf of Matt Arsenault) on 04/08/2026 at 06:51..
AMDGPU: Export the TargetParser feature bitset (#212946)

Previously this bitset was only used to populate the feature
name string map used by clang. Eventually this will replace
the current bitmask integer. AArch64 already has a similar
interface.

Co-authored-by: Claude (Claude-Opus-4.8)
https://invent.kde.org/qt/clang/llvm-project/-/commit/1fef59b860b4bba1cf4593563c25717a34cef2e4

Git commit 4bdf31cf09320fd498f8d01fc5e45a4fac6572d2 by GitHub (on behalf of Orlando Cazalet-Hyams) on 04/08/2026 at 07:00..
[dyndbg] Add Dynamic Debugging docs (#210001)

Co-authored-by: Andrew Ng <[email protected]>
https://invent.kde.org/qt/clang/llvm-project/-/commit/4bdf31cf09320fd498f8d01fc5e45a4fac6572d2

Git commit 8f53e523b92ccdc5074acc02c1c103149c20530a by GitHub (on behalf of Pavel Labath) on 04/08/2026 at 07:04..
[libc] Add program_invocation(_short)_name and tweak err.h functions (#212448)

These GNU extensions hold the name of the program as invoked (argv[0])
and its short name (the basename after the last slash).

Both variables are initialized in the startup code. As with all of our
other variables, they are only available in full build mode.

The trickiest part of this patch are the error reporting functions from
<err.h>, which access this variable, and they are currently enabled in
overlay mode. To make them work, I add an #ifdef to select the right
version. I considered doing something more elaborate, like we have with
`errno`, but that seemed too heavy for a single occurrence.

I also drop the linux check in this function. The documentation says the
functions should print the "last component of the program name", which
"llvmlibc" is not. If someone wants to enable these functions on
non-linux, they can figure out what they want to print here and how.

Assisted by Gemini.
https://invent.kde.org/qt/clang/llvm-project/-/commit/8f53e523b92ccdc5074acc02c1c103149c20530a

Git commit de15318e859adab7ea803b519e64b563c3a1751b by GitHub (on behalf of Arseniy Obolenskiy) on 04/08/2026 at 07:04..
[CGProfile] Fix unhandled error crash on empty canonical function names (#201821)

A function whose entire name is a strippable suffix canonicalizes to an
empty name, making InstrProfSymtab::create return an error

The current solution with `(void)(bool)` does not really suppress the
error which leads to the crash
https://invent.kde.org/qt/clang/llvm-project/-/commit/de15318e859adab7ea803b519e64b563c3a1751b

Git commit f1dde546716c51d3e8d619778c0b1198fc86007b by GitHub (on behalf of Valentin Churavy) on 04/08/2026 at 07:10..
[flang] Export fir-opt symbols for MLIR dialect/pass plugins (#212152)

Lets plugins loaded with --load-dialect-plugin / --load-pass-plugin
resolve
MLIR and LLVM symbols against fir-opt, as mlir-opt already does.

---------

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

Git commit 72f34740c279432f3bffd38175b464f4b918afd2 by GitHub (on behalf of David Green) on 04/08/2026 at 07:35..
[AArch64][GlobalISel] Update a batch of tests to concrete types. NFC (#213851)
https://invent.kde.org/qt/clang/llvm-project/-/commit/72f34740c279432f3bffd38175b464f4b918afd2

Git commit 20a2329148626aa66db555558af9d607035a8bf2 by GitHub (on behalf of Yao Qi) on 04/08/2026 at 07:56..
[lldb][Mach-O] Fix load-command loops spinning on cmdsize = 0 (#205134)

Every function in `ObjectFileMachO` and `ObjectContainerMachOFileset`
that iterates over load commands advances the file offset by
`lc.cmdsize` after reading each command.  A malformed command with
cmdsize smaller than `sizeof(load_command)` (in particular cmdsize = 0)
does not make forward progress, so the loop spins for ncmds iterations.
With `ncmds` close to `INT_MAX` the function never returns in practice.

Factor the read-and-validate step into a static template helper
`ReadMachOCommand<T>` in each plugin's translation unit.  It reads the
8-byte cmd/cmdsize header and returns false on EOF or on a cmdsize that
is too small to make forward progress.  All load-command loops now use
this helper, replacing the previously duplicated GetU32 + cmdsize
check.  `T` may be `llvm::MachO::load_command` or any of its richer
variants (uuid_command, dylib_command, thread_command, ident_command,
encryption_info_command, ...).   The helper only touches the leading
cmd/cmdsize fields, leaving the rest of `T` for the caller to fill in.

Affected loops in `ObjectFileMachO`:
  IsStripped, GetEncryptedFileRanges, CreateSections, ParseSymtab,
  GetUUID (static), GetAllArchSpecs (two loops), GetDependentModules,
  GetEntryPointAddress, GetNumThreadContexts, FindLC_NOTEByName,
  GetIdentifierString, GetVersion, FindMinimumVersionInfo

And in ObjectContainerMachOFileset:
  ParseFileset

Add unit tests (`ObjectFileMachOTest::ZeroCmdSize` and
`ObjectContainerMachOFilesetTest::ZeroCmdSize`) that feed a 40-byte
Mach-O with `ncmds = 0x7FFFFFFF` and `cmdsize = 0` into the relevant
parsers.  Without the fix the tests spin ~2 billion iterations; with
the fix they return immediately.  Found by lldb-target-fuzzer.

Assisted-by: Claude
https://invent.kde.org/qt/clang/llvm-project/-/commit/20a2329148626aa66db555558af9d607035a8bf2

Git commit ad0465266346682f39a44e7ca9e971b5fa101cc2 by GitHub (on behalf of Sairudra More) on 04/08/2026 at 08:05..
[flang][OpenMP] Lower allocator-backed storage for allocate clauses (#211621)

Part of #211620.

This is the first of two stacked changes implementing OpenMP `allocate`
clause lowering for fixed-size intrinsic scalar `private` and
`firstprivate` items on host `omp.parallel`.

It carries each allocate item’s private-storage mapping through the
OpenMP dialect, allocates with the requested allocator (using the
runtime default for an omitted or null handle), and releases the storage
during region finalization.

The `align` modifier is handled by the stacked follow-up.

Assisted-by: Copilot
https://invent.kde.org/qt/clang/llvm-project/-/commit/ad0465266346682f39a44e7ca9e971b5fa101cc2

Git commit 6339d8be9aae9b2a48c3ac7c329b7b7a75e62350 by GitHub (on behalf of Luke Lau) on 04/08/2026 at 08:33..
[GitHub] Use base repository to fetch test merge commit in test-suite workflow (#213871)

From time to time we'll fail to fetch the test merge commit during the
checkout step, e.g. see
https://github.com/llvm/llvm-project/actions/runs/30626469894/job/91931527829

After a bit of research apparently the test merge commit is actually
stored on the base repository, not the fork. I think this just happened
to work previously because the fork repository synced objects in the
background, but it's not always guaranteed to be available.

So switch the checkout step to use llvm/llvm-project as the remote.
https://invent.kde.org/qt/clang/llvm-project/-/commit/6339d8be9aae9b2a48c3ac7c329b7b7a75e62350

Git commit 27e6d832069729d75a76e7776737bf4477dde5a8 by GitHub (on behalf of Petar Avramovic) on 04/08/2026 at 08:35..
AMDGPU/GlobalISel: Precommit tests for upcoming bug fix (#213701)

Here we have:
artifact combiner creating one element unmerge and
unmerge lowering of FP source using FP type for bit twiddling.
https://invent.kde.org/qt/clang/llvm-project/-/commit/27e6d832069729d75a76e7776737bf4477dde5a8

Git commit 77cc70278e0ad13e8c30e691d22db03984c476a0 by GitHub (on behalf of Petar Avramovic) on 04/08/2026 at 08:40..
GlobalISel: Add type size guards in tryCombineMergeLike (#213702)

Bug in LegalizationArtifactCombiner when:
DstSize < UnmergeSrcSize case can create unmerge with one element.
DstSize > UnmergeSrcSize case can end up attempting to create merge
with one source element and hits assert(TmpVec.size() > 1).
https://invent.kde.org/qt/clang/llvm-project/-/commit/77cc70278e0ad13e8c30e691d22db03984c476a0

Git commit 62ec1d0f53114cfafb0c111321dd4217f2972de8 by GitHub (on behalf of Nikolas Klauser) on 04/08/2026 at 08:46..
[libc++abi][NFC] Enable modernize-use-override clang-tidy check (#213253)
https://invent.kde.org/qt/clang/llvm-project/-/commit/62ec1d0f53114cfafb0c111321dd4217f2972de8

Git commit a44620dad09537ba10d22e241c6f2ba011c65bea by GitHub (on behalf of Nikolas Klauser) on 04/08/2026 at 08:47..
[libc++abi][NFC] Enable modernize-loop-convert clang-tidy check (#213250)
https://invent.kde.org/qt/clang/llvm-project/-/commit/a44620dad09537ba10d22e241c6f2ba011c65bea

Git commit 24d2a96518ced6d86219d0aa2b9ad7326271fd8e by GitHub (on behalf of Petar Avramovic) on 04/08/2026 at 08:49..
GlobalISel: Fix floating point unmerge lowering (#213703)

Bitcast to integer and use integer type for bit twiddling.
https://invent.kde.org/qt/clang/llvm-project/-/commit/24d2a96518ced6d86219d0aa2b9ad7326271fd8e

Git commit 293d7c559bdf21c9739d3c389d9a4932da461620 by GitHub (on behalf of CarolineConcatto) on 04/08/2026 at 08:57..
[AArch64][SME]Refine memory effects for SME load/store intrinsics. (#205525)

Split SME load/store intrinsic definitions so loads and stores model
ArgMem, ZA, and ZT0 effects separately. Also mark ZA enable/disable as
     side-effecting intrinsics with no memory access.
https://invent.kde.org/qt/clang/llvm-project/-/commit/293d7c559bdf21c9739d3c389d9a4932da461620

Git commit 4b0b8cbac0f567cdacfde0c81019fc6c0d27f251 by GitHub (on behalf of David Sherwood) on 04/08/2026 at 09:00..
[LV] Add vplan folds for urem(X, PowerOf2) -> and(X, PowerOf2 - 1) (#212198)

In this PR I've added support for the vplan fold:

  urem(X, Y) -> and(X, Y - 1)

when Y is a power of 2. This should reduce the cost of the urem and
ensure the vplan is accurately costed. Such a change would normally
affect over 300 test files due to this being a common pattern in the
vector preheader. For now, I've limited the scope to only simplifying
occurences that are not in the vector preheader. In a follow-on PR I
will extend this to add support for

  sub(X, urem(X, Y)) -> and(X, -Y)

as well permitting folds in the preheader.
https://invent.kde.org/qt/clang/llvm-project/-/commit/4b0b8cbac0f567cdacfde0c81019fc6c0d27f251

Git commit 586e6593ebb55c2c2e9244c16ba5fee6c14198e5 by GitHub (on behalf of Simon Pilgrim) on 04/08/2026 at 09:29..
[X86] vector-reduce-*-bool.ll - update IR to match middleend (#213876)

InstCombine converts vXi1 logic reductions to bitcasted scalar integer
ops - we should be testing that, not llvm.vector.reduce.*.vXi1 calls

We were also failing to tag the i1 return values as zeroext

Shows a couple of hidden issues - poor handling of comparison results
from sub-128-bit vectors and handling of v32i1/v64i1 MOVMSK patterns on
pre-AVX2 targets
https://invent.kde.org/qt/clang/llvm-project/-/commit/586e6593ebb55c2c2e9244c16ba5fee6c14198e5

Git commit b4deecd89085c11225c428cbb27c2e44925e78d9 by GitHub (on behalf of Baranov Victor) on 04/08/2026 at 09:40..
[clang-tidy] Add 'or-earlier' suffix to check_clang_tidy.py (#213834)
https://invent.kde.org/qt/clang/llvm-project/-/commit/b4deecd89085c11225c428cbb27c2e44925e78d9

Git commit b631e0cbd1c9e33f29a199b3028026ded89167bd by GitHub (on behalf of Yao Qi) on 04/08/2026 at 09:56..
[lldb][debugserver] Expedite the stopped frame's stack memory in jThreadsInfo (#212706)

Add `ReadFrameZeroStackMemory`, which expedites the innermost frame's stack
memory so a variables view on a stop is served from lldb's memory cache.  When
frame 0's `$fp` looks usable, two windows are expedited:

  * `[$fp + 2*ptr_size, $fp + 2*ptr_size + k_expedite_stack_arg_size)` for stack-passed
     parameters, starting above the saved `{fp, lr}` pair the backchain already covers.
  * `[$fp - below, $fp)`, `below = min($fp - $sp, k_expedite_stack_window - k_expedite_stack_arg_size)`,
     for locals and spilled register arguments.  A small frame gets all of `[$sp, $fp)`; a large one keeps the part nearest `$fp`, so the cost stays bounded.

If `$fp` fails validation (frameless leaf, or `$fp` used as a scratch GPR),
a single `[$sp, $sp + k_expedite_stack_window)` window is expedited instead.

Each window is a separate chunk, because lldb's L1 cache only serves reads
fully contained in one expedited chunk.  Only the thread that stopped gets
these windows, so the stop reply does not grow with thread count.

`GetJSONThreadsInfo` now builds the `"memory"` array from both sources and
emits it whenever either produced an entry.  Add `JSONGenerator::Array::empty`
for that check.
https://invent.kde.org/qt/clang/llvm-project/-/commit/b631e0cbd1c9e33f29a199b3028026ded89167bd

Git commit c193e741cce0e29cce9350acb1fdef77182b96f1 by Luke Lau on 04/08/2026 at 10:04..
Merge branch 'main' of github.com:llvm/llvm-project into users/lukel97/loop-vectorize/simplify-recipe-return-value
https://invent.kde.org/qt/clang/llvm-project/-/commit/c193e741cce0e29cce9350acb1fdef77182b96f1

Git commit d6cfc03897a4219323c772dfbd9720faf06d590d by Luke Lau on 04/08/2026 at 10:29..
Precommit test
https://invent.kde.org/qt/clang/llvm-project/-/commit/d6cfc03897a4219323c772dfbd9720faf06d590d

Git commit 64fa13322ac9fe9f3a3f4d78c22520031fba25c0 by Luke Lau on 04/08/2026 at 10:35..
[VPlan] Process simplifyRecipes in a worklist

This brings simplifyRecipes further in line with InstCombine, and asides from unlocking more simplifications it also helps avoid spurious test churn whenever passes are moved around simplifyRecipes.

For now just push the new recipe onto the worklist, not its users.
This uses a post order traversal so we maintain the same simplification order as before.

I've gone through and checked every simplification we do is a canonicalisation that converges, and I checked on llvm-test-suite + SPEC CPU 2017 in various configurations that we don't hit any cycles.
https://invent.kde.org/qt/clang/llvm-project/-/commit/64fa13322ac9fe9f3a3f4d78c22520031fba25c0