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

Git repository change summary for qt/clang/llvm
Pushed by mirror-service into branch 'upstream/main'.
Changed from 11038cc1618ac1f801e4029b7149f68f3ad949f5 to 4e0d78f974499e728de1ee1acbdce1e6491a610c
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 1ac9b999f8b521b5d6d82cf1a19858bc40a18c6a by GitHub (on behalf of Med Ismail Bennani) on 01/08/2026 at 23:23..
[lldb] Reimplement PythonCallable::GetArgInfo without executing Python code (#213378)

`b05a5d0a` added an arity-trimming step to the shared
`ScriptedPythonInterface::Dispatch`: extensions are now allowed to
define methods with trailing parameters as optional
(`num_children(self)` vs. `num_children(self, max_count)`), so before
calling into a method, `Dispatch` needs to know how many positional
arguments it actually accepts and drop any trailing ones we'd otherwise
pass.

That check calls `PythonCallable::GetArgInfo`, which ran a whole
embedded Python script through `inspect.signature` on every call, since
every scripted-extension dispatch goes through it.

For the common case `GetArgInfo()` actually needs to handle fast (plain
Python functions/methods, classes used as constructors, and callable
instances defining `__call__`, i.e. everything `Dispatch<T>()` and
`CreatePluginObject()` ever pass it), the answer is available as plain
data attributes, with no Python bytecode execution required:
`__func__`/`__self__` to unwrap bound methods, and `__code__`'s
`co_argcount`/`co_flags` for the actual positional-argument count and
varargs bit. For a class, that means `__init__` -- except a class may
customize `__new__` instead and leave `__init__` untouched, in which
case `object.__init__` becomes lenient about extra arguments.

Anything else still lacking `__code__` can fall back to the original
`inspect.signature()`-based implementation, now exposed as
`PythonCallable::GetArgInfoFromInspectSignature()` so it can be used
separately.

rdar://183776556

---------

Signed-off-by: Med Ismail Bennani <[email protected]>
https://invent.kde.org/qt/clang/llvm/-/commit/1ac9b999f8b521b5d6d82cf1a19858bc40a18c6a

Git commit 303e63dbd87fcd700990d9c79ee80be7896e529c by GitHub (on behalf of Marc Auberer) on 02/08/2026 at 00:32..
[JITLink] Remove LTmp workaround now that LLVM requires C++17 (#213428)

C++17 guarantees the postfix-expression naming the called function is
sequenced before evaluation of its arguments, so
L->linkPhase1(std::move(L)) is well-formed without the LTmp indirection.
This should also be implemented by MSVC now. See here (P0145R3 and
P0400R0):

https://learn.microsoft.com/ar-sa/cpp/overview/visual-cpp-language-conformance?view=msvc-170
Disclaimer: As I have no LLVM Windows machine with MSVC at hand, I was
not able to test it myself.

Co-authored-by: Claude <[email protected]>
https://invent.kde.org/qt/clang/llvm/-/commit/303e63dbd87fcd700990d9c79ee80be7896e529c

Git commit 676d48fb49ceded2fc56b21bbf2f611759fbc5e0 by GitHub (on behalf of Fangrui Song) on 02/08/2026 at 01:17..
[ELF,SPARC] Handle GOTDATA relocations (#213497)

A PIC data reference forms the symbol's GOT offset with
R_SPARC_GOTDATA_OP_HIX22 and R_SPARC_GOTDATA_OP_LOX10 and loads through
it, with R_SPARC_GOTDATA_OP marking the load:

```
sethi %gdop_hix22(sym), %g1
xor   %g1, %gdop_lox10(sym), %g1
ldx   [%l7 + %g1], %g1, %gdop(sym)
```

When the symbol is neither preemptible nor absolute, optimize the load
to `add %l7, %g1, %g1` over the symbol's GOT-relative address. An
absolute symbol keeps the GOT load, as it can be arbitrarily far from
.got and we don't want the X86_64::relaxOpt complexity.

Co-authored-by: Kirill A. Korinsky <[email protected]>
Co-authored-by: LemonBoy <[email protected]>
Co-authored-by: Alex Rønne Petersen <[email protected]>
https://invent.kde.org/qt/clang/llvm/-/commit/676d48fb49ceded2fc56b21bbf2f611759fbc5e0

Git commit b32d4f0c451f2c6c19e1508441e78033c6f95e9b by GitHub (on behalf of Arun Thangamani) on 02/08/2026 at 02:03..
[mlir][x86] Decouple Accumulator from ADD-Based Vector Contractions (over loops) (#204327)

This path transforms `vector.contract(A, B, Acc)` into
`vector.contract(A, B, 0) + Acc` to decouple the contraction computation
from the accumulator update for contractions over the loop.
https://invent.kde.org/qt/clang/llvm/-/commit/b32d4f0c451f2c6c19e1508441e78033c6f95e9b

Git commit 4e0d78f974499e728de1ee1acbdce1e6491a610c by GitHub (on behalf of Fangrui Song) on 02/08/2026 at 02:34..
[ELF,SPARC] Handle TLS IE relocations (#213500)

An initial-exec reference loads the symbol's TP-relative offset from the
GOT and adds the thread pointer:

```
sethi %tie_hi22(sym), %o0             # R_SPARC_TLS_IE_HI22
add   %o0, %tie_lo10(sym), %o0        # R_SPARC_TLS_IE_LO10
ldx   [%l7 + %o0], %o0, %tie_ldx(sym) # R_SPARC_TLS_IE_LDX
add   %g7, %o0, %o0, %tie_add(sym)    # R_SPARC_TLS_IE_ADD
```

The sethi and add form the GOT offset. In an executable a
non-preemptible symbol is optimized to Local Exec, as GNU ld does: the
sethi holds the complement, the add becomes an xor, and the load becomes
a register move, or a nop when source and destination are the same. The
thread pointer add is unchanged.

Co-authored-by: Kirill A. Korinsky <[email protected]>
Co-authored-by: LemonBoy <[email protected]>
Co-authored-by: Alex Rønne Petersen <[email protected]>
https://invent.kde.org/qt/clang/llvm/-/commit/4e0d78f974499e728de1ee1acbdce1e6491a610c