[mlir][x86] Support rank-reducing RHS reads in AMX online packing (#232279)
Allows AMX online packing to handle rank-reducing RHS reads.
For a rank-reducing read, the sizes miss the dropped leading unit dims,
which hit an assertion when creating the subview. The packing loads also
indexed the subview with the read's leading offsets twice.
Assisted-by: Claude
[flang] Fail fir.global conversion when the type has no LLVM equivalent (#232610)
`GlobalOpConversion` passed the result of `convertType` straight to
`LLVM::GlobalOp::create`. For a global whose type the FIR type converter
cannot lower, such as tensor<10xi32>, that result is null and
TypeAttr::get segfaults.
Return a match failure instead so the conversion reports that
`fir.global` could not be legalized.
Assisted-by: Claude code
Signed-off-by: Keshav Vinayak Jha <keshavvinayakjha at gmail.com>
[libc] Move linux signal mask helpers into OSUtil/sigmask.h (#232647)
Move internal signal set and mask helpers (full_set, empty_set, add,
remove, block_all, set_mask, etc.) out of signal_utils.h and into a new
src/__support/OSUtil/linux/sigmask.h header under the signals namespace.
This allows other low-level OS utilities and entrypoints to manipulate
signal masks without pulling in signal_utils.h (defined under
src/signal).
The rest of signal_utils.h should also move, but I'm leaving that for a
separate PR (and a separate file) because the rest of the file has more
dependencies (RwLock, vdso, __restore_rt), and interacts with more
components.
Along with the move:
- fix full_set() on 32-bit systems: sigset_t{{-1UL}} only set the first
word, leaving real-time signals unmasked. Now we loop over __signals.
- rename the helpers to shorter names within the signals namespace
(add_signal -> add, delete_signal -> remove, restore_signals ->
[5 lines not shown]
[SPIRV] Emit DebugLexicalBlockDiscriminator for a DILexicalBlockFile.
A location scoped at a DILexicalBlockFile was emitted as a DebugScope of the compilation unit, so the discriminator did not round-trip.
Use the discriminator as the DebugScope operand, matching SPIRV-LLVM-Translator.
[mlir][linalg] Reject non-unit strides when vectorizing insert_slice (#221293)
`vectorizeAsInsertSliceOp` writes the source back with a
`vector.transfer_write` at the slice offsets, which cannot express a
stride. An insert with stride 3 was written to rows 0 and 1 instead of
rows 0 and 3. Bail out in the precondition unless all strides are 1.
Part of #227821.
[AMDGPU] Narrow 64-bit setcc to only test lower 32 bits (#232433)
Narrow 64-bit compare to a lower 32-bit compare if upper 32-bits are
known to be equal.
---------
Signed-off-by: John Lu <John.Lu at amd.com>
[MLIR][Tensor] Allow tensor-result scalarization with public callers (#231447)
Private callees should be scalarized even when called by public
functions. `tensor.from_elements` preserves existing tensor uses without
changing public signatures.
- Simplify DFS to recurse only into candidate callers, removing
redundant checks and the `moduleFunctions` set.
- Add coverage for private call chains with public callers and unchanged
public call boundaries.
- Rename the tensor-consumer test to reflect that its caller is
scalarized.
Validation: C++ syntax and diff checks passed. Runtime verification
requires rebuilding mlir-opt.
I leveraged AI to write this PR.
[StructurizeCFG] Simplify uniform region check (#232665)
When deciding whether a region can be left unstructurized, only check
that the conditional branches of its direct child blocks are uniform.
Sub-regions are processed before their parent, so divergent control flow
inside a sub-region has already been structurized and is self-contained:
it rejoins at Flow blocks inside the sub-region, or at the sub-region's
exit if its entry dominates the exit. Uniform control flow around it
therefore never needs structurizing. (Sub-regions whose entry ends in a
callbr are an exception, because run() leaves them unstructurized; that
was not handled by the old check either.)
The old check additionally required either every branch in every
sub-region to carry !structurizecfg.uniform metadata, or at most one
conditional branch among the direct children. Those conditions were
precautions that were never shown to be necessary, and they caused
uniform control flow around a divergent sub-region to be structurized
needlessly. tuple-allocation-failure.ll changes for this reason, and its
[15 lines not shown]
[LoopUnroll] Combine metadata when CSE'ing loads after unrolling (#232267)
loadCSE() replaces a load with an earlier load of the same address, but
it leaves the earlier load's metadata as it is. If the earlier load has
!nonnull or !range and the replaced one doesn't, a null or out-of-range
value becomes poison for all the users of the replaced load, while in
the original program they saw a well-defined value.
This calls combineMetadataForCSE(M, Load, /*DoesKMove=*/false) before
the RAUW, the same as EarlyCSE does. That drops the poison-generating
metadata from the surviving load unless it also has !noundef.
Fixes #231395
DeadMachineInstructionElim: Mark unread physreg defs dead (#232730)
When DeadMachineInstructionElim deletes all readers of a physreg def,
the def was left live. It already tracks liveness in its backward walk,
so mark non-reserved physreg defs that are not live afterward as dead.
The newly dead $eflags/CC defs let MachineSink move some flag-setting
arithmetic, which accounts for the codegen changes.
Co-authored-by: Claude Opus 5.5 <noreply at anthropic.com>
[libc++abi][test] Remove `XFAIL` in `cxa_thread_atexit_test.pass.cpp` (#232638)
The multiple definition problem was fixed in
cfe1b90e7cda8f2e801e23316c89e3800c5f363e so we should enable the test
for LLVM libc now.
[SYCL] Normalize the device image target triple (#231446)
clang-sycl-linker now records the target triple of each SYCL offload
image in
its normalized three-part form, architecture-vendor-operating_system.
Only the architecture component tells which binary format an image
holds, so
libsycl no longer compares the triple as a whole. DeviceImageManager
extracts
that component once, when the image is registered, and keeps it as a
std::string_view that the per-kernel compatibility check reuses.
Assisted-by: Claude Code.
---------
Signed-off-by: Tikhomirova, Kseniya <kseniya.tikhomirova at intel.com>
[CIR][DYNLIB] Make CIR/MLIR related symbols hidden in libclang-cpp.so. (#232409)
It was brought up on a different review that the cost of enabling
ClangIR by default was a significant runtime cost, even without
fclangir. From an instruction count, I found a ~8.5 million instruction
increase caused by the loader having to see all these symbols.
Reducing these gets us down to about a 300k overhead here, which reduces
the time measured on my machine of around 0.11% increase on a file
including std::vector, which feels reasonable. An empty TU overhead
looks to be in the high-1% increase due to the ~300k additional
instructions of loading.
AI disclosure: I used it extensively here, but I think I understand what
is going on, to the best of my ability to understand linking and CMake
(which is minimal :/).
[libcxx] fix missing `__get_locale_encoding()` for OpenBSD (#228306)
Fixes errors like this:
/home/alexrp/Sources/ziglang/zig-llvm23/lib/libcxx/src/text_encoding.cpp:34:43:
error: no member named '__get_locale_encoding' in namespace
'std::__locale'
34 | return
__make_text_encoding(__locale::__get_locale_encoding(static_cast<__locale::__locale_t>(0)));
| ^~~~~~~~~~~~~~~~~~~~~
/home/alexrp/Sources/ziglang/zig-llvm23/lib/libcxx/src/text_encoding.cpp:48:41:
error: no member named '__get_locale_encoding' in namespace
'std::__locale'
48 | return __make_text_encoding(__locale::__get_locale_encoding(__l));
| ^~~~~~~~~~~~~~~~~~~~~
2 errors generated.
[libc][printf] Fix %e/%g formatting in float320 algorithm (#232721)
Commit 509679cf9c9db71, updating arrays of char to a more general CharT,
removed a memset in the float320 code and replaced it with default
zero-initialization of the containing object. But the memset was to
`'0'`, not to `0`, so this changed the output. Restored the correct
initialization, this time using a for loop so that it will work even if
CharT is >1 byte.
[AArch64][llvm] Combine SVE AND-NOT operations into BIC for _m forms
Replace NOT followed by merging AND with BIC for expressions such as:
return svand_u32_m(pg, a, svnot_u32_x(pg, b));
Combine when NOT is the second operand and its predicate matches the AND
predicate or is all-active.
Use predicated BIC to preserve the AND's first operand in inactive
lanes. Use unpredicated BIC when the AND predicate is all-active.
Do not commute merging AND operands, since this would change inactive
results. Leave pairs with incompatible predicates unchanged.
This applies to all integer element widths. Update the pre-commit LLVM
expectations, including cases where combining would change the
result.
[AArch64][llvm] Combine SVE AND-NOT operations into BIC for _x forms
Replace NOT followed by AND with BIC for expressions such as:
return svand_u32_x(svptrue_b32(), a, svnot_u32_x(svptrue_b32(), b));
Combine ordinary AND with NOT when the NOT predicate is all-active or
its inactive values are undefined.
Also combine matching-predicate SVE AND_x-NOT pairs before lowering
discards the AND predicate. AND_x ignores inactive results, so the NOT's
inactive values do not need preserving.
This applies to all integer element widths. Update the pre-commit LLVM
expectations, including cases where combining would change the
result.
[AArch64][llvm] Add pre-commit tests for SVE AND-NOT combining
Add LLVM tests for expressions where NOT followed by AND could
use BIC. Record the existing assembly so the following changes show the
missed optimisations being fixed.
Cover _x and _m AND forms using all-active and runtime predicates. Test
_m forms across all integer element widths. Include NOT with defined
inactive values and reversed AND operands.
Also test cases that must remain as NOT followed by AND because
combining would change the values in inactive lanes.
[clang][ThreadSafety] Fix a crash on a capability expression calling a pointer to member (#231995)
`translateCXXMemberCallExpr` looks for calls to `get()` on smart
pointers through `CXXMemberCallExpr::getMethodDecl()`, which returns
null for a call through a pointer to member function, so a capability
expression such as `(g->*g->mu_of)()->Lock()` dereferenced null.
The call then reaches `translateCallExpr`, where its callee, a
pointer-to-member operator, is not translated and became the callee of a
`til::Call`. An `Undefined` compares equal to any other `Undefined`, so
such calls through different objects were taken for one capability, and
nested in a `Call` the `Undefined` escaped
`CapabilityExpr::isInvalid()`, so nothing was reported. Propagate the
`Undefined` as the result of the call instead, which the analysis
reports as "cannot resolve lock expression" like any other unsupported
expression.
Assisted-by: Claude Fable 5.1
[SLP][X86] Add pre-commit tests for merging bin-op input operands (#210004)
Add baseline SLP vectorizer tests covering the merge-input-operands
transform, including cases that exercise IR flag propagation (fast-math
flags, integer nsw/nuw wrap flags, and the exact flag on shifts) onto
the merged operand node. These checks reflect current (pre-transform)
codegen; a follow-up patch enables the transform and updates the checks
to show the delta.
Co-authored-by: Balakrishna Bandlapalli <bbandlap at gmail.com>
Co-authored-by: Cursor <cursoragent at cursor.com>
[clang][ThreadSafety] Fix a crash on a capability expression calling a pointer to member (#231995)
`translateCXXMemberCallExpr` looks for calls to `get()` on smart
pointers through `CXXMemberCallExpr::getMethodDecl()`, which returns
null for a call through a pointer to member function, so a capability
expression such as `(g->*g->mu_of)()->Lock()` dereferenced null.
The call then reaches `translateCallExpr`, where its callee, a
pointer-to-member operator, is not translated and became the callee of a
`til::Call`. An `Undefined` compares equal to any other `Undefined`, so
such calls through different objects were taken for one capability, and
nested in a `Call` the `Undefined` escaped
`CapabilityExpr::isInvalid()`, so nothing was reported. Propagate the
`Undefined` as the result of the call instead, which the analysis
reports as "cannot resolve lock expression" like any other unsupported
expression.
Assisted-by: Claude Fable 5.1
[clang][ThreadSafety] Resolve sibling members of function pointer fields against the called object (#231602)
d1e84bb9ad3b allowed thread safety attributes on function pointer
fields, but an attribute naming a sibling member of the struct was
translated without an implicit object, so for
struct Dev {
Mutex mu;
void (*lock)(void) ACQUIRE(mu);
};
`dev->lock()` did not acquire `dev->mu`. In C the field was translated
as a bare `mu` that matched no object's `mu`; in C++ the `this->mu` that
Sema builds was substituted with the placeholder `this` of the enclosing
function, so inside a member function of `Dev` a call through another
object was silently taken as a lock of the enclosing object's `mu`.
Use the base of the member access through which the field is called as
the implicit object for the attributes on that field. The member access
[6 lines not shown]
[ScalarEvolution] Avoid duplicate range computation for singleton steps (#232653)
When the step range contains a single value, its signed minimum and
maximum are equal, so we can skip the second affine range calculation
and reuse the first result. This reduces compile-time instruction counts
by 0.27% for mafft and 0.14% for lencod at O3.
[Clang] Fix crash classifying a dependent call to a non-callable value (#220110)
Clang asserts in Type::castAs<FunctionType> (via
CallExpr::getCallReturnType) when a template argument contains a call
whose callee has already been substituted to a plain value while an
argument is still dependent, e.g.
```cpp
template <auto V> struct W {
static constexpr auto value = V;
template <class T> auto f(T) -> W<value(T::value)>;
};
template struct W<42>;
```
When W<42> is instantiated, the callee `value` becomes an int but
T::value is still dependent, so BuildCallExpr creates a dependent
CallExpr (the MayBeFunctionType guard from #139246 intentionally lets
DeclRefExpr callees through so the error is deferred to instantiation).
[17 lines not shown]
