[CodeGenPrepare] Handle ExtractValueInst in dupRetToEnableTailCallOpts

[Carrot]

Summary

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.

[arsenm]

llvm/lib/CodeGen/CodeGenPrepare.cpp

2111–2113

getIndices() == { 0 }?

llvm/test/CodeGen/X86/tailcall-extract.ll

3

Should also have a run line checking the IR after just codegenprepare

29

Use a named value

[arsenm]

llvm/test/CodeGen/X86/tailcall-extract.ll

29

Also should test the case where the extracted value is also bit casted

[Carrot]

llvm/lib/CodeGen/CodeGenPrepare.cpp

2111–2113

The structure may be nested, so the index array size can be larger than 1.

[arsenm]

llvm/lib/CodeGen/CodeGenPrepare.cpp

2111–2113

Can you add a test with this case? ssd::all would also be shorter

[arsenm]

llvm/test/CodeGen/X86/tailcall-extract.ll

45

Should stress both the single index case like before, as well as the multi index. Also needs negative tests with non-0 indexes

[Carrot]

ping

[arsenm]

LGTM

llvm/test/CodeGen/X86/tailcall-extract.ll

131

Comments explaining each testcase wouldn't hurt, and/or more descriptive function names

[Carrot]

Thanks, will commit this version.

llvm/lib/CodeGen/CodeGenPrepare.cpp

bool CodeGenPrepare::dupRetToEnableTailCallOpts(BasicBlock *BB, bool &ModifiedDT) {
   if (!TLI)
     return false;
 
   ReturnInst *RetI = dyn_cast<ReturnInst>(BB->getTerminator());
   if (!RetI)
     return false;
 
   PHINode *PN = nullptr;
+  ExtractValueInst *EVI = nullptr;
   BitCastInst *BCI = nullptr;
   Value *V = RetI->getReturnValue();
   if (V) {
     BCI = dyn_cast<BitCastInst>(V);
     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;
   }
 
   if (PN && PN->getParent() != BB)
     return false;
 
   // Make sure there are no instructions between the PHI and return, or that the
   // return is the first instruction in the block.
   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 {
     BasicBlock::iterator BI = BB->begin();
     while (isa<DbgInfoIntrinsic>(BI)) ++BI;
     if (&*BI != RetI)
       return false;
   }

llvm/lib/Transforms/Utils/BasicBlockUtils.cpp

for (User::op_iterator i = NewRet->op_begin(), e = NewRet->op_end();
     if (BitCastInst *BCI = dyn_cast<BitCastInst>(V)) {
       // Return value might be bitcasted. Clone and insert it before the
       // return instruction.
       V = BCI->getOperand(0);
       NewBC = BCI->clone();
       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);
       }
     }
   }
 
   // Update any PHI nodes in the returning block to realize that we no

llvm/test/CodeGen/X86/tailcall-extract.ll

+; RUN: llc -mtriple=x86_64-linux < %s | FileCheck %s
+; RUN: opt -codegenprepare -S -mtriple=x86_64-linux < %s | FileCheck %s --check-prefix OPT
+
+; CHECK-LABEL: test:
+; CHECK:       jmp bar # TAILCALL
+; CHECK:       jmp foo # TAILCALL
+
+; OPT-LABEL:   test
+; OPT:         if.then.i:
+; OPT-NEXT:    tail call { { i8*, i64 }, i64 } @bar
+; OPT-NEXT:    extractvalue
+; OPT-NEXT:    bitcast
+; OPT-NEXT:    ret
+;
+; OPT:         if.end.i:
+; OPT-NEXT:    tail call { { i8*, i64 }, i64 } @foo
+; OPT-NEXT:    extractvalue
+; OPT-NEXT:    bitcast
+; OPT-NEXT:    ret
+
+define i64* @test(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 } @bar(i64 %size)
+  br label %exit
+
+if.end.i:                                         ; preds = %entry
+  %call2.i = tail call { {i8*, i64}, i64 } @foo(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
+}
+
+declare { {i8*, i64}, i64 } @foo(i64)
+declare { {i8*, i64}, i64 } @bar(i64)