deedc7bfe3
When a target region is placed inside a constant false condition (e.g.,
`if (.false.)`), the dead code gets eliminated on the host side,
removing the `omp.target` operation entirely. However, the device-side
compilation pipeline is unaware of this elimination and attempts to
generate kernel code. Since the host never created offload metadata for
the eliminated target, the device-side kernel function lacks the
"kernel" attribute, causing `OpenMPOpt` to fail with an assertion when
it expects all outlined kernels to have this attribute. The problem can
be seen with the following code:
```fortran
program cele
implicit none
real :: V
integer :: i
if (.false.) then
!$omp target teams distribute parallel do
do i = 1, 5
V = V * 2
end do
!$omp end target teams distribute parallel do
end if
end program
```
It currently fails with the following assertion:
```
Assertion `omp::isOpenMPKernel(*Kernel) && "Expected kernel function!"' failed.
llvm/lib/Transforms/IPO/OpenMPOpt.cpp:4291
```
This PR adds `DeleteUnreachableTargetsPass` that identifies `omp.target`
operations in unreachable code blocks and removes them.
80 lines
2.5 KiB
C++
80 lines
2.5 KiB
C++
//===- DeleteUnreachableTargets.cpp --------------------------------------===//
|
|
//
|
|
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
|
// See https://llvm.org/LICENSE.txt for license information.
|
|
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// This pass removes OpenMP target operations that are in unreachable code.
|
|
// This ensures host and device compilation have consistent target regions.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "flang/Optimizer/Dialect/FIRDialect.h"
|
|
#include "flang/Optimizer/Dialect/FIROps.h"
|
|
#include "flang/Optimizer/OpenMP/Passes.h"
|
|
#include "mlir/Analysis/DataFlow/DeadCodeAnalysis.h"
|
|
#include "mlir/Analysis/DataFlow/Utils.h"
|
|
#include "mlir/Analysis/DataFlowFramework.h"
|
|
#include "mlir/Dialect/Func/IR/FuncOps.h"
|
|
#include "mlir/Dialect/OpenMP/OpenMPDialect.h"
|
|
#include "mlir/IR/BuiltinOps.h"
|
|
#include "mlir/Pass/Pass.h"
|
|
#include "mlir/Support/LLVM.h"
|
|
#include "llvm/ADT/SmallVector.h"
|
|
|
|
namespace flangomp {
|
|
#define GEN_PASS_DEF_DELETEUNREACHABLETARGETSPASS
|
|
#include "flang/Optimizer/OpenMP/Passes.h.inc"
|
|
} // namespace flangomp
|
|
|
|
using namespace mlir;
|
|
|
|
namespace {
|
|
|
|
/// Check if an operation is unreachable using DeadCodeAnalysis.
|
|
static bool isOperationUnreachable(Operation *op, DataFlowSolver &solver) {
|
|
Block *block = op->getBlock();
|
|
if (!block)
|
|
return false;
|
|
|
|
// Query DeadCodeAnalysis to check if the block is live (reachable).
|
|
ProgramPoint *point = solver.getProgramPointBefore(block);
|
|
const dataflow::Executable *executable =
|
|
solver.lookupState<dataflow::Executable>(point);
|
|
|
|
return (executable && !executable->isLive());
|
|
}
|
|
|
|
class DeleteUnreachableTargetsPass
|
|
: public flangomp::impl::DeleteUnreachableTargetsPassBase<
|
|
DeleteUnreachableTargetsPass> {
|
|
public:
|
|
DeleteUnreachableTargetsPass() = default;
|
|
|
|
void runOnOperation() override {
|
|
auto module = getOperation();
|
|
DataFlowSolver solver;
|
|
dataflow::loadBaselineAnalyses(solver);
|
|
|
|
if (failed(solver.initializeAndRun(module))) {
|
|
signalPassFailure();
|
|
return;
|
|
}
|
|
|
|
// Collect unreachable target operations
|
|
SmallVector<omp::TargetOp> unreachableTargets;
|
|
module.walk([&](omp::TargetOp targetOp) {
|
|
if (isOperationUnreachable(targetOp.getOperation(), solver))
|
|
unreachableTargets.push_back(targetOp);
|
|
});
|
|
|
|
// Delete unreachable target operations
|
|
for (omp::TargetOp targetOp : unreachableTargets)
|
|
targetOp->erase();
|
|
}
|
|
};
|
|
|
|
} // namespace
|