[DWARFLinker] Index Swift mangled type names in the parallel linker (#216429)
Swift records a type's mangled name in DW_AT_linkage_name. The classic
linker indexes it as a type accelerator entry alongside the short
DW_AT_name, but the parallel linker indexed only the short name.
Port the DW_LANG_Swift block added to the classic linker in 8234f8ae2685
to the parallel linker's type case.
[SLP]Recalculate copyable-element deps after tree reordering
Reordering permutes the operand columns of the entries and may move an
operand between copyable-covered and plain edges, making the computed
dependency counts stale and tripping the unscheduled-deps assertion.
Reviewers:
Pull Request: https://github.com/llvm/llvm-project/pull/216442
[RISCV] Remove short-forward-branch-imm. (#216401)
Just use short-forward-branch-ialu. I hope implentations that implement
short-forward-branch, do it equally for all branch types. Doing anything
else would create complex tradeoffs.
I'm planning to add conditional c.mv fusion support for Zibi and I don't
want to add an immediate version flag there.
The patterns that checked NoShortForwardBranchImm were not checking that
an immediate branch ISA was enabled. So I've changed them to
NoVendorXqcibiOrNoShortForwardBranch.
[NFC][SLP] Add a test for fma fusion with the fmul on operand 1 (#216428)
canConvertToFMA only looks at operand 0 of the fadd, so the accumulator
shape fadd c, a * b is never recognised, and the fmul it does find is
priced with the target's fusion discount already applied. The threshold
puts the decision right at the cost boundary so the checks record which
way SLP goes today.
[DWARFLinker] Constrain a function's high_pc to its own symbol (#216432)
Mach-O objects built with .subsections_via_symbols make every symbol an
independently placeable atom, and the linker packs atoms without
preserving the spacing they had in the object file.
I have an example where the compiler describes such a subprogram as
extending past its own atom. While it's debatable whether that's a good
idea, it's not invalid in the object file. However, once linked, it is
invalid.
We can make dsymutil resilient against this by looking at the size of
the symbol in the debug map and adjusting the end_pc. I'm doing so
conservatively so that only a collision is repaired. Already
overlapping/invalid ranges remain untouched.
rdar://184768778
[LLVMABI] Create a skeleton for AArch64 ABI handling (#216222)
This change adds the most basic implementation of llvm::abi::TargetInfo
for AArch64 targets and establishes a unit test for it.
There was no isolated testing for previous targets implemented in the
ABI library. They were only tested through clang. My plan with AArch64
is to create unit tests so that the library can be tested without
building the clang target, but also to have clang tests so that the
handling can be compared to clang's ABI handling as a meaningful point
of reference for correct behavior.
For this initial change, because no real handling is implemented yet, I
am not introducing the clang hook or any clang-based tests.
Assisted-by: Cursor / Grok 4.5 (test generation)
[lldb] Search for a corefile's images before loading any of them (#216431)
A userland or kernel corefile can list hundreds of images, and searching
for one can shell out to a symbol server or fetch over the network.
Searching for them one at a time is where loading such a corefile spends
its time.
Add a batch form of SymbolLocator::Locate that runs the searches on the
debugger's thread pool, gated on target.parallel-module-load. Results
come back in the order the requests were given, since that order decides
the Target's module order. Only the results are ordered, and anything a
search reports to the user arrives in whatever order the searches finish
in.
Only the plugin searches run concurrently, so a platform hook does not
have to be thread safe to take part, and reading a binary's UUID out of
memory stays on the calling thread.
Setting up a platform binary can replace the Target's platform and
[5 lines not shown]
Undo botched rebase (#216421)
When rebasing #215393, I accidentally pulled in the change for #215952.
I then later rebased the latter, leaving only the changes requested
during review. Undo this mess so I can land the two PRs correctly.
[Support] Remove deprecated endian::byte_swap/read/write overloads (#216300)
These overloads took the endianness as a template parameter and were
deprecated in favour of the versions that take it as a function
argument. There are no remaining in-tree users, so drop them.
Co-authored-by: Claude <noreply at anthropic.com>
[MLIR][TableGen] Fix EnumAttr not recognized as enum in OpFormatGen (#189046)
`Attribute::isEnumAttr()` checked `isSubClassOf("EnumAttrInfo")`, but
the newer `EnumAttr` class (from `mlir/include/mlir/IR/EnumAttr.td`)
extends `AttrDef`, not `EnumAttrInfo`. This caused `canFormatEnumAttr`
in `OpFormatGen.cpp` to return `false` for `EnumAttr`-backed attributes,
forcing them to use the generic format path instead of the enum keyword
format path.
The fix has two parts:
1. Update `Attribute::isEnumAttr()` to also check
`isSubClassOf("EnumAttr")`.
2. Add `getEnumInfoRecord()` helper in `OpFormatGen.cpp` that, for
`EnumAttr`-based attributes, retrieves the `enum` sub-field (which is
the actual `EnumInfo` record) rather than the attribute def itself.
Update `canFormatEnumAttr`, `genEnumAttrParser`, and
`genEnumAttrPrinter` to use this helper.
Add a test to `op-format.td` verifying that an `EnumAttr`-wrapped enum
[4 lines not shown]
[clang][include-cleaner] Support ObjC @selector expressions in WalkAST (#212564)
This change adds support for resolving Objective-C @selector expressions
to their corresponding method or property declarations.
A lazy secondary pass is introduced to map selectors to their
declarations (methods, property getters, and property setters) across
the translation unit. When the AST walker encounters an
ObjCSelectorExpr, it reports the matching declarations as ambiguous
references.
[clang] Fix RecursiveASTVisitor to traverse the exception parameter in ObjCAtCatchStmt. (#216125)
Ensures that the catch parameter declaration (the exception variable) in
an Objective-C @catch block is visited during AST traversal. Previously,
this declaration was skipped. A unit test has been added to verify the
fix.
RuntimeLibcalls: Fix AArch64 wrongly typed long-double libcalls
Respect the triple's LongDoubleFormat.
AArch64SystemLibrary added the fp128-typed frexpl/ldexpl and exp10l without a
long-double-format guard, so triples where long double is IEEE double
(Darwin, Windows, Android) were emitting l suffixed calls with the wrong
type.
Co-authored-by: Claude (Claude-Opus-4.8) <noreply at anthropic.com>
RuntimeLibcalls: Stop improperly reporting fp128 long double calls on ARM (#215917)
32-bit ARM's long double is IEEE double, so l suffixed calls do not have
fp128 type. Additionally, the f128 typed / suffixed functions are not built in
glibc as __HAVE_FLOAT128 is defined to 0 in the arch config. Remove the
testcases which emitted nonexistent or wrongly typed calls and replace with
error tests.
Related: #44744
Co-authored-by: Claude (Claude-Opus-4.8) <noreply at anthropic.com>
---------
Co-authored-by: Claude (Claude-Opus-4.8) <noreply at anthropic.com>
Co-authored-by: Paul Kirth <paulkirth at google.com>
[lldb] Run TestDenyAttach only with locally built debug server (#216399)
The PT_DENY_ATTACH handling is in debugserver, so a system debugserver
still reports lost connection. Added @skipIfOutOfTreeDebugserver
[ABI][CIR][NFC] Mark the last X86AVXABILevel in the enum (#216339)
CIR CallConvLowering keeps one classifier per AVX level, so it sizes an
array by the number of levels. It got that number as the current end of
the list plus one, which stops being the count the moment a level is
added after the current end. A runtime assert was necessary to guard the
index.
The enum now names its own last enumerator and CallConvLowering derives
the count from it.
Follow-up to review feedback deferred on #215118.
Assisted-by: Cursor / claude-opus-5
[libc] Fix link errors in some hermetic tests (#216406)
There is a dependency loop between the __libc__ and the
LibcHermeticTestSupport targets. If a compiler introduces a call to
`extern "C" memcpy` to some __libc__ function, then we need to link
LibcHermeticTestSupport to satisfy that. But the hermetic implementation
simply forwards to LIBC_NAMESPACE::memcpy, which is in the __libc__
target.
Linking the libc library twice is a simple though unsatisfying solution
to this problem. I'm working on a more principled fix, but that is going
to take a while longer, so I'm adding this in the mean time.
[CIR] Mark record members as data, pad, or empty in CIRGen (#215175)
A record type still can't say whether it carries anything for argument
passing. The x86_64 classifier has to know that before it can drop an
empty class from a signature.
A field's mark comes from `isEmptyFieldForABI`, ported from
`isEmptyField` in `ABIInfoImpl.cpp`. Taking the ABI predicate rather
than the layout one is what gets C right. Given `struct E {}`, a struct
holding one `E` is empty for the ABI in C but not in C++.
An assert on every record checks the marks against
`isEmptyRecordForABI`, so the existing `-fclangir` tests exercise them.
One case is now NYI. A `[[no_unique_address]]` field that
`isEmptyFieldForLayout` drops from the layout can still hold ABI data.
With the field gone there is no member left to mark, so CIRGen says so
rather than emit a record that understates what it holds.
[4 lines not shown]
[lldb] Read `read-only` pointee data from the object file in `GetPointeeData` (#213372)
## Summary
`ValueObject::GetPointeeData` reads multi-element pointee data through
`eAddressTypeLoad` by calling
`Target::ReadMemory` with `force_live_memory=true`. That forces the read
to
come from live process memory and skips the object file's read-only
section cache.
For data that lives in a read-only section (e.g. a `const char *` or
**array**
in `.rodata`), the correct bytes may only be available from the object
file rather than the live process image. This is common with core files,
where read-only, file-backed pages are frequently not dumped: reading
such a pointee then returns stale or empty data (for example, a
`const char *` summary rendering as **""** instead of its real
contents).
[52 lines not shown]
[lldb] Wrap Target::GetAPIMutex() into a Lockable handle (NFC) (#212872)
While implementing #208242, we realized that we needed a Lockable
wrapper for the Target's API Mutex that could skip the locking on
re-entrant threads (when a command (i.e `bt`) triggers scripted
extension (i.e `ScriptedFrameProvider`) that uses SBAPI (i.e.
`SBFrame`), and still behave as a normal mutex otherwise. However, since
`Target::GetAPIMutex()` returns a `std::recursive_mutex&`, that can't
represent "no synchronization at all".
This is why this PR introduces `TargetAPILock`, a small Lockable type
that behaves exactly like `std::recursive_mutex`, with no RAII of its
own, so callers can wrap it in `std::lock_guard`/`std::unique_lock` like
they would any other Lockable.
A `TargetAPILock` is bound to a `Target` rather than to a specific
mutex, so `lock()`/`try_lock()` resolve which real mutex to use fresh on
every call instead of caching one resolution for the handle's lifetime.
`unlock()` replays whatever the matching `lock()`/`try_lock()` resolved
[18 lines not shown]
