[RewriteStatepointsForGC] Exclude noreturn calls from doing GC liveness analysis

[• chenli]

Summary

noreturn calls can never return normally so they do not need GC safepoints. Therefore, don't waste time on doing liveness analysis for them.

[reames]

lib/Transforms/Scalar/RewriteStatepointsForGC.cpp

1009

I'd rename this slightly. NoReturn is a well defined concept. Given the invoke case, this is more like doesntNeedLivePointers or something.

1035

I'd be tempted to move this check inside the liveness analysis since you're still returning the correct result, just differently.

Also, what are you actually saving in compute time here? Isn't walking back from the end of the block just as fast?

test/Transforms/RewriteStatepointsForGC/noreturn-calls.ll

6

Please don't check for this debug output. Checking that there are no gc.relocates would be more appropriate.

20

Please trim unneeded deopt args.

lib/Transforms/Scalar/RewriteStatepointsForGC.cpp

for (Value *Ptr : Temp) {
       errs() << " derived %" << Ptr->getName() << " base %" << Base->getName()
              << "\n";
     }
   }
 
   result.PointerToBase = PointerToBase;
 }
 
+// noreturn call can never return normally so it does not need
+// a GC safepoint. Therefore, don't waste time on doing liveness
+// analysis for it.
+static bool isNoReturnCall(const CallSite &CS) {
+  // Be conservative on invokes
+  if (CS.isInvoke()) { return false; }
+  // Explicitly marked as noreturn
+  if (CS.hasFnAttr(Attribute::NoReturn)) { return true; }
+  // Effectively noreturn if the next instruction is unreachable
+  return CS.getInstruction()->getNextNode() &&
+      isa<UnreachableInst>(CS.getInstruction()->getNextNode());
+}
+
 /// Given an updated version of the dataflow liveness results, update the
 /// liveset and base pointer maps for the call site CS.
 static void recomputeLiveInValues(GCPtrLivenessData &RevisedLivenessData,
                                   const CallSite &CS,
                                   PartiallyConstructedSafepointRecord &result);
 
 static void recomputeLiveInValues(
     Function &F, DominatorTree &DT, Pass *P, ArrayRef<CallSite> toUpdate,
     MutableArrayRef<struct PartiallyConstructedSafepointRecord> records) {
   // TODO-PERF: reuse the original liveness, then simply run the dataflow
   // again.  The old values are still live and will help it stablize quickly.
   GCPtrLivenessData RevisedLivenessData;
   computeLiveInValues(DT, F, RevisedLivenessData);
   for (size_t i = 0; i < records.size(); i++) {
     struct PartiallyConstructedSafepointRecord &info = records[i];
     const CallSite &CS = toUpdate[i];
+    if (!isNoReturnCall(CS)) {
       recomputeLiveInValues(RevisedLivenessData, CS, info);
     }
   }
+}
 
 // When inserting gc.relocate calls, we need to ensure there are no uses
 // of the original value between the gc.statepoint and the gc.relocate call.
 // One case which can arise is a phi node starting one of the successor blocks.
 // We also need to be able to insert the gc.relocates only on the path which
 // goes through the statepoint.  We might need to split an edge to make this
 // possible.
 static BasicBlock *

 static void findLiveReferences(
     Function &F, DominatorTree &DT, Pass *P, ArrayRef<CallSite> toUpdate,
     MutableArrayRef<struct PartiallyConstructedSafepointRecord> records) {
   GCPtrLivenessData OriginalLivenessData;
   computeLiveInValues(DT, F, OriginalLivenessData);
   for (size_t i = 0; i < records.size(); i++) {
     struct PartiallyConstructedSafepointRecord &info = records[i];
     const CallSite &CS = toUpdate[i];
+    if (!isNoReturnCall(CS)) {
       analyzeParsePointLiveness(DT, OriginalLivenessData, CS, info);
     }
   }
+}
 
 /// Remove any vector of pointers from the liveset by scalarizing them over the
 /// statepoint instruction.  Adds the scalarized pieces to the liveset.  It
 /// would be preferrable to include the vector in the statepoint itself, but
 /// the lowering code currently does not handle that.  Extending it would be
 /// slightly non-trivial since it requires a format change.  Given how rare
 /// such cases are (for the moment?) scalarizing is an acceptable comprimise.
 static void splitVectorValues(Instruction *StatepointInst,

test/Transforms/RewriteStatepointsForGC/noreturn-calls.ll

+; RUN:  opt %s -rewrite-statepoints-for-gc -spp-print-liveset -S 2>&1 | FileCheck %s
+
+; We're testing to make sure noreturn call does not need liveness analysis and thus
+; there's no live varibales for them 
+
+; CHECK-NOT: Live Variables:
+
+
+%jObject = type { [8 x i8] }
+
+declare void @some_call(%jObject addrspace(1)*)
+
+; Function Attrs: noreturn nounwind
+define void @"test"(%jObject addrspace(1)* %arg, i1 %cond) #0 gc "statepoint-example" {
+bci_0:
+  br i1 %cond, label %branch1, label %branch2
+
+branch1:
+; effectively noreturn call because it's unreachable after call
+  %safepoint_token0 = tail call i32 (i64, i32, void (%jObject addrspace(1)*)*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidp1jObjectf(i64 0, i32 0, void (%jObject addrspace(1)*)* @some_call, i32 1, i32 0, %jObject addrspace(1)* %arg, i32 5, i32 0, i32 -1, i32 0, i32 0, i32 0, i32 0) 
+  unreachable
+
+branch2:
+; explicitly marked as noreturn
+  %safepoint_token1 = tail call i32 (i64, i32, void (%jObject addrspace(1)*)*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidp1jObjectf(i64 0, i32 0, void (%jObject addrspace(1)*)* @some_call, i32 1, i32 0, %jObject addrspace(1)* %arg, i32 5, i32 0, i32 -1, i32 0, i32 0, i32 0, i32 0) noreturn
+  ret void
+}
+
+declare i32 @llvm.experimental.gc.statepoint.p0f_isVoidp1jObjectf(i64, i32, void (%jObject addrspace(1)*)*, i32, i32, ...)
+
+attributes #0 = { noreturn nounwind "gc-add-backedge-safepoints"="true" "gc-add-call-safepoints"="true" "gc-add-entry-safepoints"="true" }