[Inlining][NFC] Introduce a InlineFunction that takes a Statepoint.

[sanjoy]

Summary

After this change, clients of InlineFunction can get it to inline
through calls / invokes wrapped in gc_statepoint. NFC because nothing
actually exercises this code path yet.

Depends on D10631

[sanjoy]

• update with fixed patch

[reames]

I'm not sure I like the semantic intent to this patch. It seems to imply that the caller needs to know whether a particular call site is a statepoint or not. I think that's a mistake. I would expect the details of inlining through a call site which happens to be a statepoint to be hidden entirely within InlineFunction.

[reames]

Forgot to say in my previous review, but I think you need to find a way to test this. Used code is not really NFC, it's just unused. I know you're planning on building on this with related patches, but this is big enough it should be tested on it's own.

One suggestion: You could restructure PlaceSafepoints to convert to insert statepoints for gc polls, then inline using the new functionality. Anything that exercises this is fine by me.

[sanjoy]

• have InlineSite dispatch over Statepoint and CallSite using a macro.
• make the PlaceSafepoints pass use this new functionality in InlineFunction to have a mode where it does not inline the gc.safepoint_poll function by itself, but does it via the AlwaysInliner pass.

[sanjoy]

I've merged D10633 and D10632 into D10758. Their combined size is not too large IMO, and keeping them together lets me avoid adding unneeded complexity via flags like -spp-dont-pre-inline-polls just for testing.

include/llvm/Transforms/Utils/Cloning.h

 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_TRANSFORMS_UTILS_CLONING_H
 #define LLVM_TRANSFORMS_UTILS_CLONING_H
 
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/Twine.h"
+#include "llvm/IR/Statepoint.h"
 #include "llvm/IR/ValueHandle.h"
 #include "llvm/IR/ValueMap.h"
 #include "llvm/Transforms/Utils/ValueMapper.h"
 
 namespace llvm {
 
 class Module;
 class Function;

 /// function by one level.
 ///
 bool InlineFunction(CallInst *C, InlineFunctionInfo &IFI,
                     bool InsertLifetime = true);
 bool InlineFunction(InvokeInst *II, InlineFunctionInfo &IFI,
                     bool InsertLifetime = true);
 bool InlineFunction(CallSite CS, InlineFunctionInfo &IFI,
                     bool InsertLifetime = true);
+bool InlineFunction(Statepoint SP, InlineFunctionInfo &IFI,
+                    bool InsertLifetime = true);
 
 } // End llvm namespace
 
 #endif

lib/Transforms/Utils/InlineFunction.cpp

public:
   explicit InlineSite(CallSite CS)
       : CalledFunction(CS.getCalledFunction()),
         CallSiteInst(CS.getInstruction()), ArgBegin(CS.arg_begin()),
         ArgEnd(CS.arg_end()), ArgSize(CS.arg_size()),
         DoesNotThrow(CS.doesNotThrow()) {
     verify();
   }
 
+  explicit InlineSite(Statepoint SP)
+      : CalledFunction(cast<Function>(SP.getActualCallee())),
+        CallSiteInst(SP.getCallSite().getInstruction()),
+        ArgBegin(SP.call_args_begin()), ArgEnd(SP.call_args_end()),
+        ArgSize(SP.getNumCallArgs()),
+        DoesNotThrow(cast<Function>(SP.getActualCallee())->doesNotThrow()) {
+    verify();
+  }
+
   Function *getCalledFunction() const { return CalledFunction; }
 
   Function *getCaller() const;
 
   Instruction *getInstruction() const { return CallSiteInst; }
 
   Value *getArgument(unsigned aidx) const {
     assert(aidx < ArgSize && "arg index out of bounds!");
bool llvm::InlineFunction(CallSite CS, InlineFunctionInfo &IFI,
   if (InlinedMustTailCalls && pred_empty(ContainingBlock))
     ContainingBlock->eraseFromParent();
   else
     TheCall->eraseFromParent();
 
   return true;
 }
 
+bool llvm::InlineFunction(Statepoint SP, InlineFunctionInfo &IFI,
+                          bool InsertLifetime) {
+  if (SP.gc_args_begin() != SP.gc_args_begin() ||
+      SP.vm_state_begin() != SP.vm_state_end() ||
+      SP.gc_transition_args_begin() != SP.gc_transition_args_end())
+    return false;
+
+  Value *ReturnValOut = nullptr;
+  bool InlinedMustTailCalls = false;
+  if (!InlineFunctionImpl(InlineSite(SP), IFI, InsertLifetime, ReturnValOut,
+                          InlinedMustTailCalls))
+    return false;
+
+  // TODO: add handling for unreachable code that may violate
+  // defs-dominate-uses.
+  if (CallInst *Result = cast_or_null<CallInst>(SP.getGCResult())) {
+    Result->replaceAllUsesWith(ReturnValOut);
+    Result->removeFromParent();
+  }
+
+  Instruction *StatepointInst = SP.getCallSite().getInstruction();
+  assert(StatepointInst->use_empty() && "gc_result should be the only use!");
+  StatepointInst->eraseFromParent();
+
+  return true;
+}
+
 namespace {
   /// A class for recording information about inlining through an invoke.
   class InvokeInliningInfo {
     BasicBlock *OuterResumeDest; ///< Destination of the invoke's unwind.
     BasicBlock *InnerResumeDest; ///< Destination for the callee's resume.
     LandingPadInst *CallerLPad;  ///< LandingPadInst associated with the invoke.
     PHINode *InnerEHValuesPHI;   ///< PHI for EH values from landingpad insts.
     SmallVector<Value*, 8> UnwindDestPHIValues;