[AMDGPU] Restore the EXEC-write assert in SIPostRA16BitMovFolding (#227890)
#227502 turned the assert into a bail-out. The backend assumes EXEC is
not written in the middle of a basic block, so restore the assert and
drop the test that wrote EXEC between the movs.
Assisted-by: Cursor
[AArch64] Add CSEL for canCreateUndefOrPoisonForTargetNode (#226946)
These nodes cannot create posion, so we can push freeze up through them
like elsewhere in DAG.
Fix host-evaluated loop-bound contexts
Host-evaluated bounds can select a different variant from lastprivate
copy-back, leaving the lastprivate value unchanged.
This fix build the loop-bound context from source constituents before
the first loop-associated construct, even when their frames have not
been entered.
[flang][Test] Cover an unstructured combined construct and collapse(force:)
Three cases the lowering handles but nothing exercised:
A combined construct whose body branching keeps it unstructured. The
GOTO jumps backwards, so the loop is not proven to terminate and the
directive cannot take it over; it keeps the TODO the deleted test
covered. A GOTO leaving the loop would not serve, nor EXIT or RETURN:
all three are rejected for a combined construct before lowering runs.
collapse(force:2) over a nest whose inner body branches within itself,
once with a CYCLE and once with GOTOs. Both levels' bounds belong on the
directive's own loop and the body is folded into a region. Two GOTOs to
two targets are needed: one IF-guarded GOTO over a single statement is
rewritten into a fir.if and never reaches the raw form.
[flang] Let a directive keep the loop it owns when its body branches
A loop whose branching is confined to its body keeps its structured
form, but the construct holding it stayed Unstructured. A directive does
not merely contain such a loop, it owns it, and its lowering reads the
construct's own classification to decide whether the loop op carries its
bounds. The directive was left with a bounds-free loop that nothing
could partition, and the loop it owns became a second one nested inside.
Reclassify a directive construct once the loops it holds no longer need
it to stay Unstructured. Children are visited first, so those loops have
already been reclassified by the time the construct is reached. A
construct whose branching leaves it is untouched, as is one holding a
branch of its own.
Taking a loop over also means genFIR(DoConstruct) -- where a plain loop
folds a body whose branching stays inside it into a region -- never runs
for that loop, so fold its body through the same helper. A construct
that takes over no loop, acc data or acc parallel without a loop
[5 lines not shown]
[flang][NFC] Correct a stale comment on loop reclassification
Two places weaken the classification now, so calling this one "the one
place" is out of date.
[AArch64] Add CSEL for canCreateUndefOrPoisonForTargetNode (#226946)
These nodes cannot create posion, so we can push freeze up through them
like elsewhere in DAG.
[CIR] Make ASTContext optional in runCIRToCIRPasses (#227128)
Read the triple and the new cir.target_abi attribute from the module
instead of the ASTContext, erroring if either is missing, so the
CIR-to-CIR pipeline can run without a live AST. Part of preparing for:
https://discourse.llvm.org/t/rfc-clangir-making-cir-pipeline-boundaries-first-class-driver-artifacts/90998/15
---------
Co-authored-by: Claude Opus 5.5 <noreply at anthropic.com>
[mlir][SPIR-V] Fix CopyMemory handling of a lone memory operands mask (#226969)
Fix `spirv.CopyMemory` with a lone memory operands mask, which per spec
applies to both operands
Verifier no longer rejects MakePointerVisible on it
[InstCombine] Fix profile propagation in zext-bool-add-sub.ll (#227949)
Mark the profiles for the created selects as unknown as we cannot know
anything about the distribution of the condition in the general case.
[flang][NFC] Correct a stale comment on loop reclassification
Two places weaken the classification now, so calling this one "the one
place" is out of date.
[flang] Let a directive keep the loop it owns when its body branches
A loop whose branching is confined to its body keeps its structured
form, but the construct holding it stayed Unstructured. A directive does
not merely contain such a loop, it owns it, and its lowering reads the
construct's own classification to decide whether the loop op carries its
bounds. The directive was left with a bounds-free loop that nothing
could partition, and the loop it owns became a second one nested inside.
Reclassify a directive construct once the loops it holds no longer need
it to stay Unstructured. Children are visited first, so those loops have
already been reclassified by the time the construct is reached. A
construct whose branching leaves it is untouched, as is one holding a
branch of its own.
Taking a loop over also means genFIR(DoConstruct) -- where a plain loop
folds a body whose branching stays inside it into a region -- never runs
for that loop, so fold its body through the same helper. A construct
that takes over no loop, acc data or acc parallel without a loop
[5 lines not shown]
[flang][NFC] Split the OpenACC construct lowering into two lanes (#227706)
genFIR(OpenACCConstruct) decided twice, in three places, whether the
construct it lowers is structured, and reassigned the evaluation it
works from halfway through: before the descent that evaluation is the
construct, after it the loop the directive absorbs. Everything
downstream had to know which one it was holding.
Give each form its own function and leave genFIR to choose between them.
One lane allocates the exit selector, lowers the evaluations the
construct holds, and emits the jump table; the other reads the collapse
clauses, descends to the absorbed depth, and lowers what is inside it.
The prologue and epilogue are short enough to state in both rather than
share.
[RISCV][P-ext] Prevent accidental matches in riscv_packed_simd.c. NFC (#227830)
The function name is printeded multiple times in the output. We need to
make sure we are matching an instruction mnemonic. The way other
existing test cases do this is by checking for a space after the
instruction name. We don't need to do this if the mnemonic contains a
period since those are replaced with underscores in the function name.
[CIR][EH] Fix scope for partial array cleanup (#227838)
There was a bug in CIR where if an array whose elements required
destruction was initialized with an ILE, we weren't properly closing the
EH cleanup scope after the initialization completed, so it enclosed the
rest of the function. The result was that if anything later in the
function threw an exception, it would trigger both the normal
destruction of the array and the leftover EH "partial" cleanup, leading
to a double-free.
This change fixes that problem by introducing a CleanupDeactivationScope
around the init list processing (where we already had a MissingFeature
marker saying this was needed). The EH cleanup scope is now closed when
the CleanupDeactivationScope object goes out of scope.
This change also caused some observable changes to existing tests where
we were previously behaving incorrectly.
Assisted-by: Cursor / various models
[flang][OpenACC] Preserve DO CONCURRENT independence in kernels loops (#227775)
`DO CONCURRENT` asserts that its iterations may execute independently.
When it is directly associated with a combined OpenACC `KERNELS LOOP`,
Flang currently lowers the loop as `auto`, unless an explicit `seq`,
`auto`, or `independent` clause is present. This patch adds a
default-enabled extension that preserves the `DO CONCURRENT`
independence assertion by lowering the loop as `independent`. This
behavior is OpenACC-conforming. Explicit loop parallelism clauses
continue to take precedence.
The extension can be disabled with:
`-fno-openacc-acc-kernels-do-concurrent-independent`
This patch also documents the extension and adds lowering tests for its
enabled and disabled behavior.
[LV] Use SCEV loop-uniformity for outer-loop branch legality (#199632)
This patch refactors the outer-loop vectorization branch legality checks
to reason about conditional branches directly instead of using the old
recursive inner-loop shape check.
The new check allows conditional branches when their condition is
either:
- loop-invariant with respect to the vectorized outer loop, or
- a compare whose operands are both SCEV loop-uniform with respect to
the vectorized outer loop.
Divergent conditional branches are still rejected, now with a more
specific diagnostic.
[KnownFPClass][NFC] Update ATTR values for atan2 tests (#224797)
Ran the following command since it was not run for
https://github.com/llvm/llvm-project/pull/223176
```
llvm/utils/update_test_checks.py \
--opt-binary build/bin/opt \
llvm/test/Transforms/Attributor/nofpclass-atan2.ll
```
[mlir][arith] Handle unsigned moduli in int-range optimizations (#224933)
`DeleteTrivialRem` reads constant moduli as signed values, causing
`remui` operations with sign-bit-set moduli to be rejected. Keep the
modulus as an `APInt` and apply signedness according to the remainder
operation.
Fixes #224630
