[llvm] ee9a3eb - [CodeGenPrepare] Handle ExtractValueInst in dupRetToEnableTailCallOpts
Guozhi Wei via llvm-commits
llvm-commits at lists.llvm.org
Wed Mar 4 11:11:31 PST 2020
Author: Guozhi Wei
Date: 2020-03-04T11:10:32-08:00
New Revision: ee9a3eba769787bd87ac47945508751dafa5a46b
URL: https://github.com/llvm/llvm-project/commit/ee9a3eba769787bd87ac47945508751dafa5a46b
DIFF: https://github.com/llvm/llvm-project/commit/ee9a3eba769787bd87ac47945508751dafa5a46b.diff
LOG: [CodeGenPrepare] Handle ExtractValueInst in dupRetToEnableTailCallOpts
As the test case shows if there is an ExtractValueInst in the Ret block, function dupRetToEnableTailCallOpts can't duplicate it into the block containing call. So later no tail call is generated in CodeGen.
This patch adds the ExtractValueInst handling code in function dupRetToEnableTailCallOpts and FoldReturnIntoUncondBranch, and later tail call can be generated for this case.
Differential Revision: https://reviews.llvm.org/D74242
Added:
llvm/test/CodeGen/X86/tailcall-extract.ll
Modified:
llvm/lib/CodeGen/CodeGenPrepare.cpp
llvm/lib/Transforms/Utils/BasicBlockUtils.cpp
Removed:
################################################################################
diff --git a/llvm/lib/CodeGen/CodeGenPrepare.cpp b/llvm/lib/CodeGen/CodeGenPrepare.cpp
index 1ac459d0aa42..052316f34bb6 100644
--- a/llvm/lib/CodeGen/CodeGenPrepare.cpp
+++ b/llvm/lib/CodeGen/CodeGenPrepare.cpp
@@ -2102,6 +2102,7 @@ bool CodeGenPrepare::dupRetToEnableTailCallOpts(BasicBlock *BB, bool &ModifiedDT
return false;
PHINode *PN = nullptr;
+ ExtractValueInst *EVI = nullptr;
BitCastInst *BCI = nullptr;
Value *V = RetI->getReturnValue();
if (V) {
@@ -2109,6 +2110,14 @@ bool CodeGenPrepare::dupRetToEnableTailCallOpts(BasicBlock *BB, bool &ModifiedDT
if (BCI)
V = BCI->getOperand(0);
+ EVI = dyn_cast<ExtractValueInst>(V);
+ if (EVI) {
+ V = EVI->getOperand(0);
+ if (!std::all_of(EVI->idx_begin(), EVI->idx_end(),
+ [](unsigned idx) { return idx == 0; }))
+ return false;
+ }
+
PN = dyn_cast<PHINode>(V);
if (!PN)
return false;
@@ -2122,7 +2131,9 @@ bool CodeGenPrepare::dupRetToEnableTailCallOpts(BasicBlock *BB, bool &ModifiedDT
if (PN) {
BasicBlock::iterator BI = BB->begin();
// Skip over debug and the bitcast.
- do { ++BI; } while (isa<DbgInfoIntrinsic>(BI) || &*BI == BCI);
+ do {
+ ++BI;
+ } while (isa<DbgInfoIntrinsic>(BI) || &*BI == BCI || &*BI == EVI);
if (&*BI != RetI)
return false;
} else {
diff --git a/llvm/lib/Transforms/Utils/BasicBlockUtils.cpp b/llvm/lib/Transforms/Utils/BasicBlockUtils.cpp
index 4ae94cec3979..2fc70bcdcf4b 100644
--- a/llvm/lib/Transforms/Utils/BasicBlockUtils.cpp
+++ b/llvm/lib/Transforms/Utils/BasicBlockUtils.cpp
@@ -902,9 +902,25 @@ ReturnInst *llvm::FoldReturnIntoUncondBranch(ReturnInst *RI, BasicBlock *BB,
Pred->getInstList().insert(NewRet->getIterator(), NewBC);
*i = NewBC;
}
+
+ Instruction *NewEV = nullptr;
+ if (ExtractValueInst *EVI = dyn_cast<ExtractValueInst>(V)) {
+ V = EVI->getOperand(0);
+ NewEV = EVI->clone();
+ if (NewBC) {
+ NewBC->setOperand(0, NewEV);
+ Pred->getInstList().insert(NewBC->getIterator(), NewEV);
+ } else {
+ Pred->getInstList().insert(NewRet->getIterator(), NewEV);
+ *i = NewEV;
+ }
+ }
+
if (PHINode *PN = dyn_cast<PHINode>(V)) {
if (PN->getParent() == BB) {
- if (NewBC)
+ if (NewEV) {
+ NewEV->setOperand(0, PN->getIncomingValueForBlock(Pred));
+ } else if (NewBC)
NewBC->setOperand(0, PN->getIncomingValueForBlock(Pred));
else
*i = PN->getIncomingValueForBlock(Pred);
diff --git a/llvm/test/CodeGen/X86/tailcall-extract.ll b/llvm/test/CodeGen/X86/tailcall-extract.ll
new file mode 100644
index 000000000000..0fd968e4734f
--- /dev/null
+++ b/llvm/test/CodeGen/X86/tailcall-extract.ll
@@ -0,0 +1,190 @@
+; RUN: llc -mtriple=x86_64-linux < %s | FileCheck %s
+; RUN: opt -codegenprepare -S -mtriple=x86_64-linux < %s | FileCheck %s --check-prefix OPT
+
+
+; The exit block containing extractvalue can be duplicated into the BB
+; containing call. And later tail call can be generated.
+
+; CHECK-LABEL: test1:
+; CHECK: jmp bar # TAILCALL
+; CHECK: jmp foo # TAILCALL
+
+; OPT-LABEL: test1
+; OPT: if.then.i:
+; OPT-NEXT: tail call { i8*, i64 } @bar
+; OPT-NEXT: extractvalue
+; OPT-NEXT: bitcast
+; OPT-NEXT: ret
+;
+; OPT: if.end.i:
+; OPT-NEXT: tail call { i8*, i64 } @foo
+; OPT-NEXT: extractvalue
+; OPT-NEXT: bitcast
+; OPT-NEXT: ret
+
+define i64* @test1(i64 %size) {
+entry:
+ %cmp.i.i = icmp ugt i64 %size, 16384
+ %add.i.i = add i64 %size, 7
+ %div.i.i = lshr i64 %add.i.i, 3
+ %phitmp.i.i = trunc i64 %div.i.i to i32
+ %cmp1.i = icmp eq i32 %phitmp.i.i, 0
+ %cmp.i = or i1 %cmp.i.i, %cmp1.i
+ br i1 %cmp.i, label %if.end.i, label %if.then.i
+ if.then.i: ; preds = %entry
+ %call1.i = tail call { i8*, i64 } @bar(i64 %size)
+ br label %exit
+
+if.end.i: ; preds = %entry
+ %call2.i = tail call { i8*, i64 } @foo(i64 %size)
+ br label %exit
+
+exit:
+ %call1.i.sink = phi { i8*, i64 } [ %call1.i, %if.then.i ], [ %call2.i, %if.end.i ]
+ %ev = extractvalue { i8*, i64 } %call1.i.sink, 0
+ %result = bitcast i8* %ev to i64*
+ ret i64* %result
+}
+
+
+; The extractvalue extracts a field with non-zero offset, so the exit block
+; can't be duplicated.
+
+; CHECK-LABEL: test2:
+; CHECK: callq bar
+; CHECK: callq foo
+
+; OPT-LABEL: test2
+; OPT: if.then.i:
+; OPT-NEXT: tail call { i8*, i64 } @bar
+; OPT-NEXT: br label %exit
+;
+; OPT: if.end.i:
+; OPT-NEXT: tail call { i8*, i64 } @foo
+; OPT-NEXT: br label %exit
+;
+; OPT: exit:
+; OPT-NEXT: phi
+; OPT-NEXT: extractvalue
+; OPT-NEXT: ret
+
+define i64 @test2(i64 %size) {
+entry:
+ %cmp.i.i = icmp ugt i64 %size, 16384
+ %add.i.i = add i64 %size, 7
+ %div.i.i = lshr i64 %add.i.i, 3
+ %phitmp.i.i = trunc i64 %div.i.i to i32
+ %cmp1.i = icmp eq i32 %phitmp.i.i, 0
+ %cmp.i = or i1 %cmp.i.i, %cmp1.i
+ br i1 %cmp.i, label %if.end.i, label %if.then.i
+ if.then.i: ; preds = %entry
+ %call1.i = tail call { i8*, i64 } @bar(i64 %size)
+ br label %exit
+
+if.end.i: ; preds = %entry
+ %call2.i = tail call { i8*, i64 } @foo(i64 %size)
+ br label %exit
+
+exit:
+ %call1.i.sink = phi { i8*, i64 } [ %call1.i, %if.then.i ], [ %call2.i, %if.end.i ]
+ %ev = extractvalue { i8*, i64 } %call1.i.sink, 1
+ ret i64 %ev
+}
+
+
+; The extractvalue accesses a nest struct type, the extracted field has zero
+; offset, so the exit block can still be duplicated, and tail call generated.
+
+; CHECK-LABEL: test3:
+; CHECK: jmp baz # TAILCALL
+; CHECK: jmp qux # TAILCALL
+
+; OPT-LABEL: test3
+; OPT: if.then.i:
+; OPT-NEXT: tail call { { i8*, i64 }, i64 } @baz
+; OPT-NEXT: extractvalue
+; OPT-NEXT: bitcast
+; OPT-NEXT: ret
+;
+; OPT: if.end.i:
+; OPT-NEXT: tail call { { i8*, i64 }, i64 } @qux
+; OPT-NEXT: extractvalue
+; OPT-NEXT: bitcast
+; OPT-NEXT: ret
+
+define i64* @test3(i64 %size) {
+entry:
+ %cmp.i.i = icmp ugt i64 %size, 16384
+ %add.i.i = add i64 %size, 7
+ %div.i.i = lshr i64 %add.i.i, 3
+ %phitmp.i.i = trunc i64 %div.i.i to i32
+ %cmp1.i = icmp eq i32 %phitmp.i.i, 0
+ %cmp.i = or i1 %cmp.i.i, %cmp1.i
+ br i1 %cmp.i, label %if.end.i, label %if.then.i
+
+if.then.i: ; preds = %entry
+ %call1.i = tail call { {i8*, i64}, i64 } @baz(i64 %size)
+ br label %exit
+
+if.end.i: ; preds = %entry
+ %call2.i = tail call { {i8*, i64}, i64 } @qux(i64 %size)
+ br label %exit
+
+exit:
+ %call1.i.sink = phi { {i8*, i64}, i64 } [ %call1.i, %if.then.i ], [ %call2.i, %if.end.i ]
+ %ev = extractvalue { {i8*, i64}, i64 } %call1.i.sink, 0, 0
+ %result = bitcast i8* %ev to i64*
+ ret i64* %result
+}
+
+
+; The extractvalue accesses a nest struct with non-zero offset, so the exit
+; block can't be duplicated.
+
+; CHECK-LABEL: test4:
+; CHECK: callq baz
+; CHECK: callq qux
+
+; OPT-LABEL: test4
+; OPT: if.then.i:
+; OPT-NEXT: tail call { { i8*, i64 }, i64 } @baz
+; OPT-NEXT: br label %exit
+;
+; OPT: if.end.i:
+; OPT-NEXT: tail call { { i8*, i64 }, i64 } @qux
+; OPT-NEXT: br label %exit
+;
+; OPT: exit:
+; OPT-NEXT: phi
+; OPT-NEXT: extractvalue
+; OPT-NEXT: ret
+
+define i64 @test4(i64 %size) {
+entry:
+ %cmp.i.i = icmp ugt i64 %size, 16384
+ %add.i.i = add i64 %size, 7
+ %div.i.i = lshr i64 %add.i.i, 3
+ %phitmp.i.i = trunc i64 %div.i.i to i32
+ %cmp1.i = icmp eq i32 %phitmp.i.i, 0
+ %cmp.i = or i1 %cmp.i.i, %cmp1.i
+ br i1 %cmp.i, label %if.end.i, label %if.then.i
+
+if.then.i: ; preds = %entry
+ %call1.i = tail call { {i8*, i64}, i64 } @baz(i64 %size)
+ br label %exit
+
+if.end.i: ; preds = %entry
+ %call2.i = tail call { {i8*, i64}, i64 } @qux(i64 %size)
+ br label %exit
+
+exit:
+ %call1.i.sink = phi { {i8*, i64}, i64 } [ %call1.i, %if.then.i ], [ %call2.i, %if.end.i ]
+ %ev = extractvalue { {i8*, i64}, i64 } %call1.i.sink, 0, 1
+ ret i64 %ev
+}
+
+
+declare { i8*, i64 } @foo(i64)
+declare { i8*, i64 } @bar(i64)
+declare { {i8*, i64}, i64 } @baz(i64)
+declare { {i8*, i64}, i64 } @qux(i64)
More information about the llvm-commits
mailing list