[Inliner] Teach LLVM to inline through statepoints.

[sanjoy]

Summary

After this change, LLVM can inline through through some calls / invokes wrapped in gc_statepoint. The cost analysis pass does not currently grok statepoints. We only inline through a gc_statepoint if the call is
marked alwaysinline.

Depends on D10631

Previously was split into D10632 and D10633.

[pgavlin]

This is looking quite a bit better. I'm going to hold off on accepting this patch until Chandler has had a chance to follow up on http://reviews.llvm.org/D10631, however.

include/llvm/IR/CallSite.h

119

From the previous review:

I think there is scope to (at least) extract out a StatepointOffsets struct with all of the constants encoded as static const ints and include that in CallSite.h as well as Statepoint.h. Do you think something like that will be sufficient?

A struct-encapsulated enum or an enum class would also be sufficient. I think any of these choices is a definite step in the right direction.

lib/Transforms/Utils/InlineFunction.cpp

151

It would be good to have a comment describing which classes of statepoints can be inlined, which cannot, if these restrictions can be loosened in the future, and the reasoning behind them.

153

Did you intend SP.gc_args_begin() != SP.gc_args_end()?

test/Transforms/Inline/statepoints-basic.ll

63

s/currenlty/currently

[sanjoy]

• address review

[sanjoy]

Some comments addressed. I'll fix the "Extract out StatepointOffsets" bit once we've reached consensus on D10631.

[pgavlin]

Looks good aside from the pending StatepointOffset refactoring and one small comment.

lib/Transforms/Utils/InlineFunction.cpp

151

I'd still like to see some explanation of why the restrictions are there and if they'll be lifted. Doesn't have to be much--even a simple // TODO at the beginning of your existing comment would suffice.

[sanjoy]

These have been superseded by the operand bundles work.

include/llvm/IR/CallSite.h

 #ifndef LLVM_IR_CALLSITE_H
 #define LLVM_IR_CALLSITE_H
 
 #include "llvm/ADT/PointerIntPair.h"
 #include "llvm/ADT/iterator_range.h"
 #include "llvm/IR/Attributes.h"
 #include "llvm/IR/CallingConv.h"
 #include "llvm/IR/Instructions.h"
+#include "llvm/IR/Intrinsics.h"
 
 namespace llvm {
 
 class CallInst;
 class InvokeInst;
 
 template <typename FunTy = const Function,
           typename BBTy = const BasicBlock,
public:
 
   /// setCalledFunction - Set the callee to the specified value.
   ///
   void setCalledFunction(Value *V) {
     assert(getInstruction() && "Not a call or invoke instruction!");
     *getCallee() = V;
   }
 
+  /// getTargetFunction - Return the final destination this call or invoke will
+  /// dispatch to if it is a function literal, with consideration to the fact
+  /// that the control flow may be carried out indirectly via gc_statepoint.
+  ///
+  FunTy *getTargetFunction() const {
+    FunTy *LiteralDest = getCalledFunction();
+    if (LiteralDest &&
+        LiteralDest->getIntrinsicID() == Intrinsic::experimental_gc_statepoint)
+      return dyn_cast<FunTy>(getArgument(2));
+
+    return LiteralDest;
+  }
+
   /// isCallee - Determine whether the passed iterator points to the
   /// callee operand's Use.
   bool isCallee(Value::const_user_iterator UI) const {
     return isCallee(&UI.getUse());
   }
 
   /// Determine whether this Use is the callee operand's Use.
   bool isCallee(const Use *U) const { return getCallee() == U; }

lib/Analysis/IPA/InlineCost.cpp

static bool functionsHaveCompatibleAttributes(Function *Caller,
   return TTI.hasCompatibleFunctionAttributes(Caller, Callee) &&
          attributeMatches(Caller, Callee, Attribute::SanitizeAddress) &&
          attributeMatches(Caller, Callee, Attribute::SanitizeMemory) &&
          attributeMatches(Caller, Callee, Attribute::SanitizeThread);
 }
 
 InlineCost InlineCostAnalysis::getInlineCost(CallSite CS, Function *Callee,
                                              int Threshold) {
-  // Cannot inline indirect calls.
-  if (!Callee)
+  // Cannot inline indirect calls or calls through intrinsics.
+  if (!Callee || Callee->isIntrinsic())
     return llvm::InlineCost::getNever();
 
   // Calls to functions with always-inline attributes should be inlined
   // whenever possible.
   if (CS.hasFnAttr(Attribute::AlwaysInline)) {
     if (isInlineViable(*Callee))
       return llvm::InlineCost::getAlways();
     return llvm::InlineCost::getNever();

lib/Transforms/IPO/InlineAlways.cpp

 /// a very simple and boring direct walk of the instructions looking for
 /// impossible-to-inline constructs.
 ///
 /// Note, it would be possible to go to some lengths to cache the information
 /// computed here, but as we only expect to do this for relatively few and
 /// small functions which have the explicit attribute to force inlining, it is
 /// likely not worth it in practice.
 InlineCost AlwaysInliner::getInlineCost(CallSite CS) {
-  Function *Callee = CS.getCalledFunction();
+  Function *Callee = CS.getTargetFunction();
 
   // Only inline direct calls to functions with always-inline attributes
   // that are viable for inlining. FIXME: We shouldn't even get here for
   // declarations.
   if (Callee && !Callee->isDeclaration() &&
       CS.hasFnAttr(Attribute::AlwaysInline) &&
       ICA->isInlineViable(*Callee))
     return InlineCost::getAlways();

lib/Transforms/IPO/Inliner.cpp

 #include "llvm/Analysis/InlineCost.h"
 #include "llvm/Analysis/TargetLibraryInfo.h"
 #include "llvm/IR/CallSite.h"
 #include "llvm/IR/DataLayout.h"
 #include "llvm/IR/DiagnosticInfo.h"
 #include "llvm/IR/Instructions.h"
 #include "llvm/IR/IntrinsicInst.h"
 #include "llvm/IR/Module.h"
+#include "llvm/IR/Statepoint.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/raw_ostream.h"
 #include "llvm/Transforms/Utils/Cloning.h"
 #include "llvm/Transforms/Utils/Local.h"
 using namespace llvm;
 
 #define DEBUG_TYPE "inline"

 /// This function also does some basic book-keeping to update the IR.  The
 /// InlinedArrayAllocas map keeps track of any allocas that are already
 /// available from other functions inlined into the caller.  If we are able to
 /// inline this call site we attempt to reuse already available allocas or add
 /// any new allocas to the set if not possible.
 static bool InlineCallIfPossible(CallSite CS, InlineFunctionInfo &IFI,
                                  InlinedArrayAllocasTy &InlinedArrayAllocas,
                                  int InlineHistory, bool InsertLifetime) {
-  Function *Callee = CS.getCalledFunction();
+  Function *Callee = CS.getTargetFunction();
   Function *Caller = CS.getCaller();
 
   // Try to inline the function.  Get the list of static allocas that were
   // inlined.
   if (!InlineFunction(CS, IFI, InsertLifetime))
     return false;
 
   AdjustCallerSSPLevel(Caller, Callee);
unsigned Inliner::getInlineThreshold(CallSite CS) const {
   bool OptSize = Caller && !Caller->isDeclaration() &&
                  Caller->hasFnAttribute(Attribute::OptimizeForSize);
   if (!(InlineLimit.getNumOccurrences() > 0) && OptSize &&
       OptSizeThreshold < thres)
     thres = OptSizeThreshold;
 
   // Listen to the inlinehint attribute when it would increase the threshold
   // and the caller does not need to minimize its size.
-  Function *Callee = CS.getCalledFunction();
+  Function *Callee = CS.getTargetFunction();
   bool InlineHint = Callee && !Callee->isDeclaration() &&
                     Callee->hasFnAttribute(Attribute::InlineHint);
   if (InlineHint && HintThreshold > thres &&
       !Caller->hasFnAttribute(Attribute::MinSize))
     thres = HintThreshold;
 
   // Listen to the cold attribute when it would decrease the threshold.
   bool ColdCallee = Callee && !Callee->isDeclaration() &&

 
 /// Return true if the inliner should attempt to inline at the given CallSite.
 bool Inliner::shouldInline(CallSite CS) {
   InlineCost IC = getInlineCost(CS);
   
   if (IC.isAlways()) {
     DEBUG(dbgs() << "    Inlining: cost=always"
           << ", Call: " << *CS.getInstruction() << "\n");
-    emitAnalysis(CS, Twine(CS.getCalledFunction()->getName()) +
+    emitAnalysis(CS, Twine(CS.getTargetFunction()->getName()) +
                          " should always be inlined (cost=always)");
     return true;
   }
   
   if (IC.isNever()) {
     DEBUG(dbgs() << "    NOT Inlining: cost=never"
           << ", Call: " << *CS.getInstruction() << "\n");
-    emitAnalysis(CS, Twine(CS.getCalledFunction()->getName() +
+    emitAnalysis(CS, Twine(CS.getTargetFunction()->getName() +
                            " should never be inlined (cost=never)"));
     return false;
   }
   
   Function *Caller = CS.getCaller();
   if (!IC) {
     DEBUG(dbgs() << "    NOT Inlining: cost=" << IC.getCost()
           << ", thres=" << (IC.getCostDelta() + IC.getCost())
           << ", Call: " << *CS.getInstruction() << "\n");
-    emitAnalysis(CS, Twine(CS.getCalledFunction()->getName() +
+    emitAnalysis(CS, Twine(CS.getTargetFunction()->getName() +
                            " too costly to inline (cost=") +
                          Twine(IC.getCost()) + ", threshold=" +
                          Twine(IC.getCostDelta() + IC.getCost()) + ")");
     return false;
   }
   
   // Try to detect the case where the current inlining candidate caller (call
   // it B) is a static or linkonce-ODR function and is an inlining candidate
if (Caller->hasLocalLinkage() || Caller->hasLinkOnceODRLinkage()) {
     // This bool tracks what happens if we DO inline C into B.
     bool inliningPreventsSomeOuterInline = false;
     for (User *U : Caller->users()) {
       CallSite CS2(U);
 
       // If this isn't a call to Caller (it could be some other sort
       // of reference) skip it.  Such references will prevent the caller
       // from being removed.
-      if (!CS2 || CS2.getCalledFunction() != Caller) {
+      if (!CS2 || CS2.getTargetFunction() != Caller) {
         callerWillBeRemoved = false;
         continue;
       }
 
       InlineCost IC2 = getInlineCost(CS2);
       ++NumCallerCallersAnalyzed;
       if (!IC2) {
         callerWillBeRemoved = false;
if (callerWillBeRemoved && !Caller->use_empty())
       TotalSecondaryCost += InlineConstants::LastCallToStaticBonus;
 
     if (inliningPreventsSomeOuterInline && TotalSecondaryCost < IC.getCost()) {
       DEBUG(dbgs() << "    NOT Inlining: " << *CS.getInstruction() <<
            " Cost = " << IC.getCost() <<
            ", outer Cost = " << TotalSecondaryCost << '\n');
       emitAnalysis(
           CS, Twine("Not inlining. Cost of inlining " +
-                    CS.getCalledFunction()->getName() +
+                    CS.getTargetFunction()->getName() +
                     " increases the cost of inlining " +
                     CS.getCaller()->getName() + " in other contexts"));
       return false;
     }
   }
 
   DEBUG(dbgs() << "    Inlining: cost=" << IC.getCost()
         << ", thres=" << (IC.getCostDelta() + IC.getCost())
         << ", Call: " << *CS.getInstruction() << '\n');
   emitAnalysis(
-      CS, CS.getCalledFunction()->getName() + Twine(" can be inlined into ") +
+      CS, CS.getTargetFunction()->getName() + Twine(" can be inlined into ") +
               CS.getCaller()->getName() + " with cost=" + Twine(IC.getCost()) +
               " (threshold=" + Twine(IC.getCostDelta() + IC.getCost()) + ")");
   return true;
 }
 
 /// Return true if the specified inline history ID
 /// indicates an inline history that includes the specified function.
 static bool InlineHistoryIncludes(Function *F, int InlineHistoryID,
bool Inliner::runOnSCC(CallGraphSCC &SCC) {
 
   for (CallGraphNode *Node : SCC) {
     Function *F = Node->getFunction();
     if (!F) continue;
     
     for (BasicBlock &BB : *F)
       for (Instruction &I : BB) {
         CallSite CS(cast<Value>(&I));
-        // If this isn't a call, or it is a call to an intrinsic, it can
-        // never be inlined.
-        if (!CS || isa<IntrinsicInst>(I))
+        // If this isn't a call never be inlined.
+        if (!CS)
           continue;
-        
+        // We can inline through gc_statepoint calls.  Calls to other intrinsics
+        // cannot be inlined.
+        if (isa<IntrinsicInst>(I) && !isStatepoint(I))
+          continue;
+
+        Function *CalledFunction = CS.getTargetFunction();
+
         // If this is a direct call to an external function, we can never inline
         // it.  If it is an indirect call, inlining may resolve it to be a
         // direct call, so we keep it.
-        if (CS.getCalledFunction() && CS.getCalledFunction()->isDeclaration())
+        if (CalledFunction && CalledFunction->isDeclaration())
           continue;
         
         CallSites.push_back(std::make_pair(CS, -1));
       }
   }
 
   DEBUG(dbgs() << ": " << CallSites.size() << " call sites.\n");
 
   // If there are no calls in this function, exit early.
   if (CallSites.empty())
     return false;
 
   // Now that we have all of the call sites, move the ones to functions in the
   // current SCC to the end of the list.
   unsigned FirstCallInSCC = CallSites.size();
   for (unsigned i = 0; i < FirstCallInSCC; ++i)
-    if (Function *F = CallSites[i].first.getCalledFunction())
+    if (Function *F = CallSites[i].first.getTargetFunction())
       if (SCCFunctions.count(F))
         std::swap(CallSites[i--], CallSites[--FirstCallInSCC]);
 
   
   InlinedArrayAllocasTy InlinedArrayAllocas;
   InlineFunctionInfo InlineInfo(&CG, AA, ACT);
 
   // Now that we have all of the call sites, loop over them and inline them if
   // it looks profitable to do so.
   bool Changed = false;
   bool LocalChange;
   do {
     LocalChange = false;
     // Iterate over the outer loop because inlining functions can cause indirect
     // calls to become direct calls.
     // CallSites may be modified inside so ranged for loop can not be used.
     for (unsigned CSi = 0; CSi != CallSites.size(); ++CSi) {
       CallSite CS = CallSites[CSi].first;
       
       Function *Caller = CS.getCaller();
-      Function *Callee = CS.getCalledFunction();
+      Function *Callee = CS.getTargetFunction();
 
       // If this call site is dead and it is to a readonly function, we should
       // just delete the call instead of trying to inline it, regardless of
       // size.  This happens because IPSCCP propagates the result out of the
       // call and then we're left with the dead call.
       if (isInstructionTriviallyDead(CS.getInstruction(), TLI)) {
         DEBUG(dbgs() << "    -> Deleting dead call: "
                      << *CS.getInstruction() << "\n");

lib/Transforms/Utils/InlineFunction.cpp

 #include "llvm/IR/DIBuilder.h"
 #include "llvm/IR/Dominators.h"
 #include "llvm/IR/IRBuilder.h"
 #include "llvm/IR/Instructions.h"
 #include "llvm/IR/IntrinsicInst.h"
 #include "llvm/IR/Intrinsics.h"
 #include "llvm/IR/MDBuilder.h"
 #include "llvm/IR/Module.h"
+#include "llvm/IR/Statepoint.h"
 #include "llvm/Transforms/Utils/Local.h"
 #include "llvm/Support/CommandLine.h"
 #include <algorithm>
 using namespace llvm;
 
 static cl::opt<bool>
 EnableNoAliasConversion("enable-noalias-to-md-conversion", cl::init(true),
   cl::Hidden,
bool llvm::InlineFunction(InvokeInst *II, InlineFunctionInfo &IFI,
                           bool InsertLifetime) {
   return InlineFunction(CallSite(II), IFI, InsertLifetime);
 }
 
 namespace {
 class InlineSite {
   CallSite CS;
 
+#define INLINESITE_DELEGATE_GETTER(METHOD)  do {        \
+    if (Statepoint SP = Statepoint(CS))                 \
+      return SP.METHOD;                                 \
+    return CS.METHOD;                                   \
+  } while (0)
+
   bool paramHasAttr(unsigned i, Attribute::AttrKind A) const {
-    return CS.paramHasAttr(i, A);
+    INLINESITE_DELEGATE_GETTER(paramHasAttr(i, A));
   }
 
 public:
   explicit InlineSite(CallSite CS) : CS(CS) { }
 
-  Function *getCalledFunction() const { return CS.getCalledFunction(); }
+  Function *getCalledFunction() const {
+    INLINESITE_DELEGATE_GETTER(getCalledFunction());
+  }
 
-  Function *getCaller() const { return CS.getCaller(); }
+  Function *getCaller() const {
+    INLINESITE_DELEGATE_GETTER(getCaller());
+  }
 
-  Instruction *getInstruction() const { return CS.getInstruction(); }
+  Instruction *getInstruction() const {
+    INLINESITE_DELEGATE_GETTER(getInstruction());
+  }
 
   Value *getArgument(unsigned Index) const {
-    return CS.getArgument(Index);
+    INLINESITE_DELEGATE_GETTER(getArgument(Index));
+  }
+
+  bool doesNotThrow() const {
+    INLINESITE_DELEGATE_GETTER(doesNotThrow());
+  }
+
+  unsigned arg_size() const {
+    INLINESITE_DELEGATE_GETTER(arg_size());
+  }
+
+  CallSite::arg_iterator arg_begin() const {
+    INLINESITE_DELEGATE_GETTER(arg_begin());
+  }
+
+  CallSite::arg_iterator arg_end() const {
+    INLINESITE_DELEGATE_GETTER(arg_end());
   }
 
   bool isByValArgument(unsigned ArgNo) const {
     return paramHasAttr(ArgNo + 1, Attribute::ByVal);
   }
-
-  bool doesNotThrow() const { return CS.doesNotThrow(); }
-  unsigned arg_size() const { return CS.arg_size(); }
-  CallSite::arg_iterator arg_begin() const { return CS.arg_begin(); }
-  CallSite::arg_iterator arg_end() const { return CS.arg_end(); }
 };
 }
 
 static bool InlineThroughInlineSite(InlineSite IS, InlineFunctionInfo &IFI,
                                     bool InsertLifetime, Value *&ReturnVal,
                                     bool &InlinedMustTailCalls);
 
-bool llvm::InlineFunction(CallSite CS, InlineFunctionInfo &IFI,
+static bool InlineGenericCallSite(CallSite CS, InlineFunctionInfo &IFI,
                                   bool InsertLifetime) {
   Value *ReturnValOut = nullptr;
   bool InlinedMustTailCalls = false;
   if (!InlineThroughInlineSite(InlineSite(CS), IFI, InsertLifetime,
                                ReturnValOut, InlinedMustTailCalls))
     return false;
 
   Instruction *TheCall = CS.getInstruction();
   if (!TheCall->use_empty()) {
     if (ReturnValOut == TheCall) // Can happen in unreachable code
       ReturnValOut = UndefValue::get(TheCall->getType());
     TheCall->replaceAllUsesWith(ReturnValOut);
   }
 
   BasicBlock *ContainingBlock = TheCall->getParent();
 
   // Entire block may have become unreachable.
   if (InlinedMustTailCalls && pred_empty(ContainingBlock))
     ContainingBlock->eraseFromParent();
   else
     TheCall->eraseFromParent();
 
   return true;
 }
 
+static bool InlineStatepoint(Statepoint SP, InlineFunctionInfo &IFI,
+                             bool InsertLifetime) {
+
+  // We currently only inline through statepoints that do not have any
+  // associated GC or deopt state.
+
+  if (SP.gc_args_begin() != SP.gc_args_end() ||
+      SP.vm_state_begin() != SP.vm_state_end() ||
+      SP.gc_transition_args_begin() != SP.gc_transition_args_end())
+    return false;
+
+  Function *Callee = SP.getCalledFunction();
+  if (!Callee->hasGC())
+    return false;
+
+  if (StringRef(Callee->getGC()) != SP.getCaller()->getGC())
+    return false;
+
+  Value *ReturnValOut = nullptr;
+  bool InlinedMustTailCalls = false;
+  if (!InlineThroughInlineSite(InlineSite(SP.getCallSite()), 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.getInstruction();
+  assert(StatepointInst->use_empty() && "gc_result should be the only use!");
+  StatepointInst->eraseFromParent();
+
+  return true;
+}
+
+bool llvm::InlineFunction(CallSite CS, InlineFunctionInfo &IFI,
+                          bool InsertLifetime) {
+  if (Statepoint SP = Statepoint(CS))
+    return InlineStatepoint(SP, IFI, InsertLifetime);
+  return InlineGenericCallSite(CS, IFI, InsertLifetime);
+}
+
 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;

test/Transforms/Inline/statepoints-basic.ll

+; RUN: opt -S -always-inline < %s | FileCheck %s
+
+declare i32 @llvm.experimental.gc.statepoint.p0f_isVoidf(i64, i32, void ()*, i32, i32, ...)
+
+@A = global i32 7
+
+declare i32* @fake_personality_function()
+
+define void @callee() gc "statepoint-example" {
+ store i32 123, i32* @A
+ ret void
+}
+
+define void @callee_nogc() {
+ store i32 123, i32* @A
+ ret void
+}
+
+define i8 addrspace(1)* @test_inline_call(i8 addrspace(1)* %obj) gc "statepoint-example" {
+; CHECK-LABEL: test_inline_call(
+entry:
+; CHECK: store i32 123, i32* @A
+  call i32 (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 0, i32 0, void ()* @callee, i32 0, i32 0, i32 0, i32 0)  alwaysinline
+  ret i8 addrspace(1)* %obj
+}
+
+define i8 addrspace(1)* @test_inline_invoke(i8 addrspace(1)* %obj) gc "statepoint-example" personality i32* ()* @fake_personality_function {
+; CHECK-LABEL: test_inline_invoke(
+entry:
+; CHECK: store i32 123, i32* @A
+  invoke i32 (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 0, i32 0, void ()* @callee, i32 0, i32 0, i32 0, i32 0)  alwaysinline to label %normal unwind label %exc
+
+ normal:
+  ret i8 addrspace(1)* %obj
+
+ exc:
+  %lpad = landingpad { i8*, i32 } cleanup
+  ret i8 addrspace(1)* null
+}
+
+define i8 addrspace(1)* @test_no_inline_1(i8 addrspace(1)* %obj) gc "statepoint-example" {
+; We don't inline function bodies that have a mismatching GC type.
+
+; CHECK-LABEL: test_no_inline_1(
+entry:
+; CHECK-NOT: store i32 123, i32* @A
+  call i32 (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 0, i32 0, void ()* @callee_nogc, i32 0, i32 0, i32 0, i32 0)  alwaysinline
+  ret i8 addrspace(1)* %obj
+}
+
+define i8 addrspace(1)* @test_no_inline_2(i8 addrspace(1)* %obj) gc "statepoint-example" {
+; Inlining through a statepoint that has gc arguments is not currently supported
+
+; CHECK-LABEL: test_no_inline_2(
+entry:
+; CHECK-NOT: store i32 123, i32* @A
+  call i32 (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 0, i32 0, void ()* @callee_nogc, i32 0, i32 0, i32 0, i32 0, i8 addrspace(1)* %obj)  alwaysinline
+  ret i8 addrspace(1)* null
+}
+
+define i8 addrspace(1)* @test_no_inline_3(i8 addrspace(1)* %obj) gc "statepoint-example" {
+; Inlining through a statepoint that has deopt arguments is not currently supported
+
+; CHECK-LABEL: test_no_inline_3(
+entry:
+; CHECK-NOT: store i32 123, i32* @A
+  call i32 (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 0, i32 0, void ()* @callee_nogc, i32 0, i32 0, i32 0, i32 1, i32 0)  alwaysinline
+  ret i8 addrspace(1)* %obj
+}