Index: llvm/include/llvm/Transforms/Utils/UnifyFunctionExitNodes.h
===================================================================
--- llvm/include/llvm/Transforms/Utils/UnifyFunctionExitNodes.h
+++ llvm/include/llvm/Transforms/Utils/UnifyFunctionExitNodes.h
@@ -23,7 +23,10 @@
class BasicBlock;
-struct UnifyFunctionExitNodes : public FunctionPass {
+class UnifyFunctionExitNodes : public FunctionPass {
+ bool unifyUnreachableBlocks(Function &F);
+ bool unifyReturnBlocks(Function &F);
+
public:
static char ID; // Pass identification, replacement for typeid
UnifyFunctionExitNodes();
Index: llvm/lib/Transforms/Utils/UnifyFunctionExitNodes.cpp
===================================================================
--- llvm/lib/Transforms/Utils/UnifyFunctionExitNodes.cpp
+++ llvm/lib/Transforms/Utils/UnifyFunctionExitNodes.cpp
@@ -42,44 +42,41 @@
AU.addPreservedID(LowerSwitchID);
}
-// UnifyAllExitNodes - Unify all exit nodes of the CFG by creating a new
-// BasicBlock, and converting all returns to unconditional branches to this
-// new basic block. The singular exit node is returned.
-//
-// If there are no return stmts in the Function, a null pointer is returned.
-//
-bool UnifyFunctionExitNodes::runOnFunction(Function &F) {
- // Loop over all of the blocks in a function, tracking all of the blocks that
- // return.
- //
- std::vector<BasicBlock*> ReturningBlocks;
+bool UnifyFunctionExitNodes::unifyUnreachableBlocks(Function &F) {
std::vector<BasicBlock*> UnreachableBlocks;
+
for (BasicBlock &I : F)
- if (isa<ReturnInst>(I.getTerminator()))
- ReturningBlocks.push_back(&I);
- else if (isa<UnreachableInst>(I.getTerminator()))
+ if (isa<UnreachableInst>(I.getTerminator()))
UnreachableBlocks.push_back(&I);
- // Then unreachable blocks.
- if (UnreachableBlocks.size() > 1) {
- BasicBlock *UnreachableBlock = BasicBlock::Create(F.getContext(),
- "UnifiedUnreachableBlock", &F);
- new UnreachableInst(F.getContext(), UnreachableBlock);
+ if (UnreachableBlocks.size() <= 1)
+ return false;
+
+ BasicBlock *UnreachableBlock =
+ BasicBlock::Create(F.getContext(), "UnifiedUnreachableBlock", &F);
+ new UnreachableInst(F.getContext(), UnreachableBlock);
- for (BasicBlock *BB : UnreachableBlocks) {
- BB->getInstList().pop_back(); // Remove the unreachable inst.
- BranchInst::Create(UnreachableBlock, BB);
- }
+ for (BasicBlock *BB : UnreachableBlocks) {
+ BB->getInstList().pop_back(); // Remove the unreachable inst.
+ BranchInst::Create(UnreachableBlock, BB);
}
- // There is nothing more to do if we do not have multiple return blocks.
+ return true;
+}
+
+bool UnifyFunctionExitNodes::unifyReturnBlocks(Function &F) {
+ std::vector<BasicBlock *> ReturningBlocks;
+
+ for (BasicBlock &I : F)
+ if (isa<ReturnInst>(I.getTerminator()))
+ ReturningBlocks.push_back(&I);
+
if (ReturningBlocks.size() <= 1)
return false;
- // Otherwise, we need to insert a new basic block into the function, add a PHI
- // nodes (if the function returns values), and convert all of the return
- // instructions into unconditional branches.
- //
+ // Insert a new basic block into the function, add PHI nodes (if the function
+ // returns values), and convert all of the return instructions into
+ // unconditional branches.
BasicBlock *NewRetBlock = BasicBlock::Create(F.getContext(),
"UnifiedReturnBlock", &F);
@@ -96,7 +93,6 @@
// Loop over all of the blocks, replacing the return instruction with an
// unconditional branch.
- //
for (BasicBlock *BB : ReturningBlocks) {
// Add an incoming element to the PHI node for every return instruction that
// is merging into this new block...
@@ -106,5 +102,16 @@
BB->getInstList().pop_back(); // Remove the return insn
BranchInst::Create(NewRetBlock, BB);
}
+
+ return true;
+}
+
+// Unify all exit nodes of the CFG by creating a new BasicBlock, and converting
+// all returns to unconditional branches to this new basic block. Also, unify
+// all unreachable blocks.
+bool UnifyFunctionExitNodes::runOnFunction(Function &F) {
+ bool Changed = false;
+ Changed |= unifyUnreachableBlocks(F);
+ Changed |= unifyReturnBlocks(F);
return true;
}
Index: llvm/test/Transforms/UnifyFunctionExitNodes/unreachable-blocks-status.ll
===================================================================
--- /dev/null
+++ llvm/test/Transforms/UnifyFunctionExitNodes/unreachable-blocks-status.ll
@@ -0,0 +1,67 @@
+; RUN: opt -mergereturn -S < %s | FileCheck %s
+
+; The pass did previously not report the correct Modified status in the case
+; where a function had at most one return block, and an unified unreachable
+; block was created. This was caught by the pass return status check that is
+; hidden under EXPENSIVE_CHECKS.
+
+; CHECK: for.foo.body2:
+; CHECK-NEXT: br label %UnifiedUnreachableBlock
+
+; CHECK: for.foo.end:
+; CHECK-NEXT: br label %UnifiedUnreachableBlock
+
+; CHECK: UnifiedUnreachableBlock:
+; CHECK-NEXT: unreachable
+
+define i32 @foo() {
+entry:
+ br label %for.foo.cond
+
+for.foo.cond: ; preds = %entry
+ br i1 false, label %for.foo.body, label %for.foo.end3
+
+for.foo.body: ; preds = %for.foo.cond
+ br label %for.foo.cond1
+
+for.foo.cond1: ; preds = %for.foo.body
+ br i1 false, label %for.foo.body2, label %for.foo.end
+
+for.foo.body2: ; preds = %for.foo.cond1
+ unreachable
+
+for.foo.end: ; preds = %for.foo.cond1
+ unreachable
+
+for.foo.end3: ; preds = %for.foo.cond
+ ret i32 undef
+}
+
+; CHECK: for.bar.body2:
+; CHECK-NEXT: br label %UnifiedUnreachableBlock
+
+; CHECK: for.bar.end:
+; CHECK-NEXT: br label %UnifiedUnreachableBlock
+
+; CHECK: UnifiedUnreachableBlock:
+; CHECK-NEXT: unreachable
+
+define void @bar() {
+entry:
+ br label %for.bar.cond
+
+for.bar.cond: ; preds = %entry
+ br i1 false, label %for.bar.body, label %for.bar.end
+
+for.bar.body: ; preds = %for.bar.cond
+ br label %for.bar.cond1
+
+for.bar.cond1: ; preds = %for.bar.body
+ br i1 false, label %for.bar.body2, label %for.bar.end
+
+for.bar.body2: ; preds = %for.bar.cond1
+ unreachable
+
+for.bar.end: ; preds = %for.bar.cond1
+ unreachable
+}