[Mlir-commits] [mlir] [mlir][llvm] Import unreachable basic blocks (PR #78467)
Tobias Gysi
llvmlistbot at llvm.org
Wed Jan 17 08:37:09 PST 2024
https://github.com/gysit created https://github.com/llvm/llvm-project/pull/78467
This revision updates the LLVM IR import to support unreachable basic blocks. An unreachable block may dominate itself and a value defined inside the block may thus be used before its definition. The import does not support such dependencies. We thus delete the unreachable basic block since MLIR does not have basic block labels that can be reached using an indirect call and unreachable blocks are indeed dead for us.
>From 43f695f35c7a81625081c23b09f4c45f964f1ef7 Mon Sep 17 00:00:00 2001
From: Tobias Gysi <tobias.gysi at nextsilicon.com>
Date: Wed, 17 Jan 2024 16:15:20 +0000
Subject: [PATCH] [mlir][llvm] Import unreachable basic blocks
This revision updates the LLVM IR import to support unreachable basic
blocks. An unreachable block may dominate itself and a value defined
inside the block may thus be used before its definition. The import does
not support such dependencies. We thus delete the unreachable basic
block since MLIR does not have basic block labels that can be reached
using an indirect call and unreachable blocks are indeed dead for us.
---
mlir/lib/Target/LLVMIR/ModuleImport.cpp | 46 +++++++++++++------
mlir/test/Target/LLVMIR/Import/constant.ll | 10 ++++
mlir/test/Target/LLVMIR/Import/exception.ll | 41 +++++++++--------
.../LLVMIR/Import/unreachable-blocks.ll | 13 ++++++
4 files changed, 75 insertions(+), 35 deletions(-)
create mode 100644 mlir/test/Target/LLVMIR/Import/unreachable-blocks.ll
diff --git a/mlir/lib/Target/LLVMIR/ModuleImport.cpp b/mlir/lib/Target/LLVMIR/ModuleImport.cpp
index 0eae42b86831b2e..5645db7a180638e 100644
--- a/mlir/lib/Target/LLVMIR/ModuleImport.cpp
+++ b/mlir/lib/Target/LLVMIR/ModuleImport.cpp
@@ -26,6 +26,7 @@
#include "mlir/Interfaces/DataLayoutInterfaces.h"
#include "mlir/Tools/mlir-translate/Translation.h"
+#include "llvm/ADT/DepthFirstIterator.h"
#include "llvm/ADT/PostOrderIterator.h"
#include "llvm/ADT/ScopeExit.h"
#include "llvm/ADT/StringSet.h"
@@ -132,18 +133,17 @@ static LogicalResult convertInstructionImpl(OpBuilder &odsBuilder,
return failure();
}
-/// Get a topologically sorted list of blocks for the given function.
+/// Get a topologically sorted list of blocks for the given basic blocks.
static SetVector<llvm::BasicBlock *>
-getTopologicallySortedBlocks(llvm::Function *func) {
+getTopologicallySortedBlocks(ArrayRef<llvm::BasicBlock *> basicBlocks) {
SetVector<llvm::BasicBlock *> blocks;
- for (llvm::BasicBlock &bb : *func) {
- if (!blocks.contains(&bb)) {
- llvm::ReversePostOrderTraversal<llvm::BasicBlock *> traversal(&bb);
+ for (llvm::BasicBlock *basicBlock : basicBlocks) {
+ if (!blocks.contains(basicBlock)) {
+ llvm::ReversePostOrderTraversal<llvm::BasicBlock *> traversal(basicBlock);
blocks.insert(traversal.begin(), traversal.end());
}
}
- assert(blocks.size() == func->size() && "some blocks are not sorted");
-
+ assert(blocks.size() == basicBlocks.size() && "some blocks are not sorted");
return blocks;
}
@@ -1856,11 +1856,26 @@ LogicalResult ModuleImport::processFunction(llvm::Function *func) {
if (func->isDeclaration())
return success();
- // Eagerly create all blocks.
- for (llvm::BasicBlock &bb : *func) {
- Block *block =
- builder.createBlock(&funcOp.getBody(), funcOp.getBody().end());
- mapBlock(&bb, block);
+ // Collect the set of basic blocks reachable from the function's entry block.
+ // This step is crucial as LLVM IR can include unreachable blocks that
+ // self-dominate. As a result, an operation might utilize a variable it
+ // defines, which the import does not support. Given that MLIR lacks block
+ // label support, we can safely remove unreachable blocks, as there are no
+ // indirect branch instructions that could potentially target these blocks.
+ llvm::df_iterator_default_set<llvm::BasicBlock *> reachable;
+ for (llvm::BasicBlock *basicBlock : llvm::depth_first_ext(func, reachable))
+ (void)basicBlock;
+
+ // Eagerly create all reachable blocks.
+ SmallVector<llvm::BasicBlock *> reachableBasicBlocks;
+ for (llvm::BasicBlock &basicBlock : *func) {
+ // Skip unreachable blocks.
+ if (!reachable.count(&basicBlock))
+ continue;
+ Region ®ion = funcOp.getBody();
+ Block *block = builder.createBlock(®ion, region.end());
+ mapBlock(&basicBlock, block);
+ reachableBasicBlocks.push_back(&basicBlock);
}
// Add function arguments to the entry block.
@@ -1873,10 +1888,11 @@ LogicalResult ModuleImport::processFunction(llvm::Function *func) {
// Process the blocks in topological order. The ordered traversal ensures
// operands defined in a dominating block have a valid mapping to an MLIR
// value once a block is translated.
- SetVector<llvm::BasicBlock *> blocks = getTopologicallySortedBlocks(func);
+ SetVector<llvm::BasicBlock *> blocks =
+ getTopologicallySortedBlocks(reachableBasicBlocks);
setConstantInsertionPointToStart(lookupBlock(blocks.front()));
- for (llvm::BasicBlock *bb : blocks)
- if (failed(processBasicBlock(bb, lookupBlock(bb))))
+ for (llvm::BasicBlock *basicBlock : blocks)
+ if (failed(processBasicBlock(basicBlock, lookupBlock(basicBlock))))
return failure();
// Process the debug intrinsics that require a delayed conversion after
diff --git a/mlir/test/Target/LLVMIR/Import/constant.ll b/mlir/test/Target/LLVMIR/Import/constant.ll
index cd2d00ec0aa7834..3c46f5b20c31ca7 100644
--- a/mlir/test/Target/LLVMIR/Import/constant.ll
+++ b/mlir/test/Target/LLVMIR/Import/constant.ll
@@ -47,6 +47,16 @@ define void @undef_constant(i32 %arg0) {
; // -----
+; CHECK-LABEL: @poison_constant
+define void @poison_constant(double %arg0) {
+ ; CHECK: %[[POISON:.+]] = llvm.mlir.poison : f64
+ ; CHECK: llvm.fadd %[[POISON]], %{{.*}} : f64
+ %1 = fadd double poison, %arg0
+ ret void
+}
+
+; // -----
+
; CHECK-LABEL: @null_constant
define ptr @null_constant() {
; CHECK: %[[NULL:[0-9]+]] = llvm.mlir.zero : !llvm.ptr
diff --git a/mlir/test/Target/LLVMIR/Import/exception.ll b/mlir/test/Target/LLVMIR/Import/exception.ll
index de227645cc15bbe..440d89ec147f767 100644
--- a/mlir/test/Target/LLVMIR/Import/exception.ll
+++ b/mlir/test/Target/LLVMIR/Import/exception.ll
@@ -12,34 +12,35 @@ define i32 @invokeLandingpad() personality ptr @__gxx_personality_v0 {
; CHECK: %[[a1:[0-9]+]] = llvm.mlir.addressof @_ZTIii : !llvm.ptr
; CHECK: %[[a3:[0-9]+]] = llvm.alloca %{{[0-9]+}} x i8 {alignment = 1 : i64} : (i32) -> !llvm.ptr
%1 = alloca i8
- ; CHECK: llvm.invoke @foo(%[[a3]]) to ^bb2 unwind ^bb1 : (!llvm.ptr) -> ()
- invoke void @foo(ptr %1) to label %4 unwind label %2
+ ; CHECK: llvm.invoke @foo(%[[a3]]) to ^[[bb1:.*]] unwind ^[[bb4:.*]] : (!llvm.ptr) -> ()
+ invoke void @foo(ptr %1) to label %bb1 unwind label %bb4
-; CHECK: ^bb1:
+; CHECK: ^[[bb1]]:
+bb1:
+ ; CHECK: %{{[0-9]+}} = llvm.invoke @bar(%[[a3]]) to ^[[bb2:.*]] unwind ^[[bb4]] : (!llvm.ptr) -> !llvm.ptr
+ %2 = invoke ptr @bar(ptr %1) to label %bb2 unwind label %bb4
+
+; CHECK: ^[[bb2]]:
+bb2:
+ ; CHECK: llvm.invoke @vararg_foo(%[[a3]], %{{.*}}) to ^[[bb3:.*]] unwind ^[[bb4]] vararg(!llvm.func<void (ptr, ...)>) : (!llvm.ptr, i32) -> ()
+ invoke void (ptr, ...) @vararg_foo(ptr %1, i32 0) to label %bb3 unwind label %bb4
+
+; CHECK: ^[[bb3]]:
+bb3:
+ ; CHECK: llvm.invoke %{{.*}}(%[[a3]], %{{.*}}) to ^[[bb5:.*]] unwind ^[[bb4]] vararg(!llvm.func<void (ptr, ...)>) : !llvm.ptr, (!llvm.ptr, i32) -> ()
+ invoke void (ptr, ...) undef(ptr %1, i32 0) to label %bb5 unwind label %bb4
+
+; CHECK: ^[[bb4]]:
+bb4:
; CHECK: %{{[0-9]+}} = llvm.landingpad (catch %{{[0-9]+}} : !llvm.ptr) (catch %[[a1]] : !llvm.ptr) (filter %{{[0-9]+}} : !llvm.array<1 x i1>) : !llvm.struct<(ptr, i32)>
%3 = landingpad { ptr, i32 } catch ptr @_ZTIi catch ptr @_ZTIii
filter [1 x i1] [i1 1]
resume { ptr, i32 } %3
-; CHECK: ^bb2:
+; CHECK: ^[[bb5]]:
+bb5:
; CHECK: llvm.return %{{[0-9]+}} : i32
ret i32 1
-
-; CHECK: ^bb3:
- ; CHECK: %{{[0-9]+}} = llvm.invoke @bar(%[[a3]]) to ^bb2 unwind ^bb1 : (!llvm.ptr) -> !llvm.ptr
- %6 = invoke ptr @bar(ptr %1) to label %4 unwind label %2
-
-; CHECK: ^bb4:
- ; CHECK: llvm.invoke @vararg_foo(%[[a3]], %{{.*}}) to ^bb2 unwind ^bb1 vararg(!llvm.func<void (ptr, ...)>) : (!llvm.ptr, i32) -> ()
- invoke void (ptr, ...) @vararg_foo(ptr %1, i32 0) to label %4 unwind label %2
-
-; CHECK: ^bb5:
- ; CHECK: llvm.invoke %{{.*}}(%[[a3]], %{{.*}}) to ^bb2 unwind ^bb1 vararg(!llvm.func<void (ptr, ...)>) : !llvm.ptr, (!llvm.ptr, i32) -> ()
- invoke void (ptr, ...) undef(ptr %1, i32 0) to label %4 unwind label %2
-
-; CHECK: ^bb6:
- ; CHECK: llvm.return %{{[0-9]+}} : i32
- ret i32 0
}
declare i32 @foo2()
diff --git a/mlir/test/Target/LLVMIR/Import/unreachable-blocks.ll b/mlir/test/Target/LLVMIR/Import/unreachable-blocks.ll
new file mode 100644
index 000000000000000..71526a61f23a000
--- /dev/null
+++ b/mlir/test/Target/LLVMIR/Import/unreachable-blocks.ll
@@ -0,0 +1,13 @@
+; RUN: mlir-translate -import-llvm %s | FileCheck %s
+
+; CHECK-LABEL: llvm.func @unreachable_block
+; CHECK-NEXT: llvm.return
+; CHECK-NOT: llvm.return
+define void @unreachable_block(float %0) {
+.entry:
+ ret void
+
+unreachable:
+ %1 = fadd float %0, %1
+ br label %unreachable
+}
More information about the Mlir-commits
mailing list