[CallSiteSplitting]use constrained argument from single predecessors

[junbuml]

Summary

If a call-site has a single predecessor, we can simply use more constrained
arguments if its argument is predicated from the single predecessor.

[mcrosier]

lib/Transforms/Scalar/CallSiteSplitting.cpp

375

return canSplitCallSite(CS) && (tryToSplitOnPredicatedArgument(CS) ||
       tryToSplitOnPHIPredicatedArgument(CS));

[fhahn]

Is CallSiteSplitting the right place to do this? Wouldn't it be a better fit for more general constraint propagation, like correlated value propagation/ LazyValueInfo?

[fhahn]

instcombine now propagates nonnull in the cases mentioned here. I'll resign to clear up my pipeline.

[junbuml]

Thanks Florian for the update.

lib/Transforms/Scalar/CallSiteSplitting.cpp

static bool tryToSplitOnPredicatedArgument(CallSite CS) {
   Instruction *CallInst2 = addConditions(CS, C2);
   if (!CallInst1 && !CallInst2)
     return false;
 
   splitCallSite(CS, Preds[1], Preds[0], CallInst2, CallInst1);
   return true;
 }
 
+static bool tryToUseConstrainedArgument(CallSite CS, BasicBlock *SinglePred) {
+  SmallVector<std::pair<ICmpInst *, unsigned>, 2> Cmps;
+  recordConditions(CS, SinglePred, Cmps);
+  if (Instruction *NewCI = addConditions(CS, Cmps)) {
+    Instruction *Instr = CS.getInstruction();
+    NewCI->insertBefore(Instr);
+    Instr->replaceAllUsesWith(NewCI);
+    Instr->eraseFromParent();
+    return true;
+  }
+  return false;
+}
+
 static bool tryToSplitCallSite(CallSite CS) {
-  if (!CS.arg_size() || !canSplitCallSite(CS))
+  if (!CS.arg_size())
     return false;
+
+  if (BasicBlock *SinglePred =
+          CS.getInstruction()->getParent()->getSinglePredecessor())
+    return tryToUseConstrainedArgument(CS, SinglePred);
+
+  if (!canSplitCallSite(CS))
+    return false;
+
   return tryToSplitOnPredicatedArgument(CS) ||
          tryToSplitOnPHIPredicatedArgument(CS);
 }
 
 static bool doCallSiteSplitting(Function &F, TargetLibraryInfo &TLI) {
   bool Changed = false;
   for (Function::iterator BI = F.begin(), BE = F.end(); BI != BE;) {
     BasicBlock &BB = *BI++;
     for (BasicBlock::iterator II = BB.begin(), IE = BB.end(); II != IE;) {

test/Transforms/CallSiteSplitting/callsite-no-or-structure.ll

 Tail:
   %r = call i32 @callee(i32* %a, i32 %v, i32 %p)
   ret i32 %r
 
 End:
   ret i32 %v
 }
 
+; CHECK-LABEL: @test_single_pred
+; CHECK-LABEL: Tail:
+; CHECK: %[[CALL:.*]] = call i32 @callee(i32* nonnull %a, i32 %v, i32 %p)
+; CHECK: ret i32 %[[CALL]]
+define i32 @test_single_pred(i1 %c, i32* %a, i32 %v, i32 %p) {
+Header:
+  br i1 %c, label %TBB, label %End
+
+TBB:
+  %cmp = icmp ne i32* %a, null
+  br i1 %cmp, label %Tail, label %End
+
+Tail:
+  %r = call i32 @callee(i32* %a, i32 %v, i32 %p)
+  ret i32 %r
+
+End:
+  ret i32 %v
+}
+
+; CHECK-LABEL: @test_single_pred_pred
+; CHECK-LABEL: Tail:
+; CHECK: %[[CALL:.*]] = call i32 @callee(i32* nonnull %a, i32 1, i32 %p)
+; CHECK: ret i32 %[[CALL]]
+define i32 @test_single_pred_pred(i1 %c, i32* %a, i32 %v, i32 %p) {
+Header:
+  br i1 %c, label %TBB, label %End
+
+TBB:
+  %cmp = icmp ne i32* %a, null
+  br i1 %cmp, label %TBB2, label %End
+
+TBB2:
+  %cmp2 = icmp eq i32 %v, 1
+  br i1 %cmp2, label %Tail, label %End
+
+Tail:
+  %r = call i32 @callee(i32* %a, i32 %v, i32 %p)
+  ret i32 %r
+
+End:
+  ret i32 %v
+}
+
+
 define i32 @callee(i32* %a, i32 %v, i32 %p) {
   ret i32 10
 }