Use ImmutableCallSite for statepoint verification.

[igor-laevsky]

Summary

This change generalizes statepoint verification to use ImmutableCallSite instead of CallInst. This will allow to easily implement invoke statepoint verification (in a following change).

[reames]

LGTM, want me to submit?

[igor-laevsky]

Yes, please.

llvm/trunk/lib/IR/Verifier.cpp

private:
   void VerifyAttributeTypes(AttributeSet Attrs, unsigned Idx, bool isFunction,
                             const Value *V);
   void VerifyParameterAttrs(AttributeSet Attrs, unsigned Idx, Type *Ty,
                             bool isReturnValue, const Value *V);
   void VerifyFunctionAttrs(FunctionType *FT, AttributeSet Attrs,
                            const Value *V);
 
   void VerifyConstantExprBitcastType(const ConstantExpr *CE);
-  void VerifyStatepoint(CallInst &CI);
+  void VerifyStatepoint(ImmutableCallSite CS);
 };
 class DebugInfoVerifier : public VerifierSupport {
 public:
   explicit DebugInfoVerifier(raw_ostream &OS = dbgs()) : VerifierSupport(OS) {}
 
   bool verify(const Module &M) {
     this->M = &M;
     verifyDebugInfo();
if (LastIndex <= Params
       || (LastIndex == AttributeSet::FunctionIndex
           && (LastSlot == 0 || Attrs.getSlotIndex(LastSlot - 1) <= Params)))
     return true;
 
   return false;
 }
 
 /// \brief Verify that statepoint intrinsic is well formed.
-void Verifier::VerifyStatepoint(CallInst &CI) {
-  assert(CI.getCalledFunction() &&
-         CI.getCalledFunction()->getIntrinsicID() ==
+void Verifier::VerifyStatepoint(ImmutableCallSite CS) {
+  assert(CS.getCalledFunction() &&
+         CS.getCalledFunction()->getIntrinsicID() ==
            Intrinsic::experimental_gc_statepoint);
 
-  Assert1(!CI.doesNotAccessMemory() &&
-          !CI.onlyReadsMemory(),
+  const Instruction &CI = *CS.getInstruction();
+
+  Assert1(!CS.doesNotAccessMemory() &&
+          !CS.onlyReadsMemory(),
           "gc.statepoint must read and write memory to preserve "
           "reordering restrictions required by safepoint semantics", &CI);
-  Assert1(!CI.isInlineAsm(),
-          "gc.statepoint support for inline assembly unimplemented", &CI);
     
-  const Value *Target = CI.getArgOperand(0);
+  const Value *Target = CS.getArgument(0);
   const PointerType *PT = dyn_cast<PointerType>(Target->getType());
   Assert2(PT && PT->getElementType()->isFunctionTy(),
           "gc.statepoint callee must be of function pointer type",
           &CI, Target);
   FunctionType *TargetFuncType = cast<FunctionType>(PT->getElementType());
 
-  const Value *NumCallArgsV = CI.getArgOperand(1);
+  const Value *NumCallArgsV = CS.getArgument(1);
   Assert1(isa<ConstantInt>(NumCallArgsV),
           "gc.statepoint number of arguments to underlying call "
           "must be constant integer", &CI);
   const int NumCallArgs = cast<ConstantInt>(NumCallArgsV)->getZExtValue();
   Assert1(NumCallArgs >= 0,
           "gc.statepoint number of arguments to underlying call "
           "must be positive", &CI);
   const int NumParams = (int)TargetFuncType->getNumParams();
   if (TargetFuncType->isVarArg()) {
     Assert1(NumCallArgs >= NumParams,
             "gc.statepoint mismatch in number of vararg call args", &CI);
 
     // TODO: Remove this limitation
     Assert1(TargetFuncType->getReturnType()->isVoidTy(),
             "gc.statepoint doesn't support wrapping non-void "
             "vararg functions yet", &CI);
   } else
     Assert1(NumCallArgs == NumParams,
             "gc.statepoint mismatch in number of call args", &CI);
 
-  const Value *Unused = CI.getArgOperand(2);
+  const Value *Unused = CS.getArgument(2);
   Assert1(isa<ConstantInt>(Unused) &&
           cast<ConstantInt>(Unused)->isNullValue(),
           "gc.statepoint parameter #3 must be zero", &CI);
 
   // Verify that the types of the call parameter arguments match
   // the type of the wrapped callee.
   for (int i = 0; i < NumParams; i++) {
     Type *ParamType = TargetFuncType->getParamType(i);
-    Type *ArgType = CI.getArgOperand(3+i)->getType();
+    Type *ArgType = CS.getArgument(3+i)->getType();
     Assert1(ArgType == ParamType,
             "gc.statepoint call argument does not match wrapped "
             "function type", &CI);
   }
   const int EndCallArgsInx = 2+NumCallArgs;
-  const Value *NumDeoptArgsV = CI.getArgOperand(EndCallArgsInx+1);
+  const Value *NumDeoptArgsV = CS.getArgument(EndCallArgsInx+1);
   Assert1(isa<ConstantInt>(NumDeoptArgsV),
           "gc.statepoint number of deoptimization arguments "
           "must be constant integer", &CI);
   const int NumDeoptArgs = cast<ConstantInt>(NumDeoptArgsV)->getZExtValue();
   Assert1(NumDeoptArgs >= 0,
           "gc.statepoint number of deoptimization arguments "
           "must be positive", &CI);
 
-  Assert1(4 + NumCallArgs + NumDeoptArgs <= (int)CI.getNumArgOperands(),
+  Assert1(4 + NumCallArgs + NumDeoptArgs <= (int)CS.arg_size(),
           "gc.statepoint too few arguments according to length fields", &CI);
     
   // Check that the only uses of this gc.statepoint are gc.result or 
   // gc.relocate calls which are tied to this statepoint and thus part
   // of the same statepoint sequence
-  for (User *U : CI.users()) {
+  for (const User *U : CI.users()) {
     const CallInst *Call = dyn_cast<const CallInst>(U);
     Assert2(Call, "illegal use of statepoint token", &CI, U);
     if (!Call) continue;
     Assert2(isGCRelocate(Call) || isGCResult(Call),
             "gc.result or gc.relocate are the only value uses"
             "of a gc.statepoint", &CI, U);
     if (isGCResult(Call)) {
       Assert2(Call->getArgOperand(0) == &CI,
case Intrinsic::framerecover: {
     Value *FnArg = CI.getArgOperand(0)->stripPointerCasts();
     Function *Fn = dyn_cast<Function>(FnArg);
     Assert1(Fn && !Fn->isDeclaration(), "llvm.framerecover first "
             "argument must be function defined in this module", &CI);
     break;
   }
 
   case Intrinsic::experimental_gc_statepoint:
-    VerifyStatepoint(CI);
+    Assert1(!CI.isInlineAsm(),
+            "gc.statepoint support for inline assembly unimplemented", &CI);
+
+    VerifyStatepoint(ImmutableCallSite(&CI));
     break;
   case Intrinsic::experimental_gc_result_int:
   case Intrinsic::experimental_gc_result_float:
   case Intrinsic::experimental_gc_result_ptr:
   case Intrinsic::experimental_gc_result: {
     // Are we tied to a statepoint properly?
     CallSite StatepointCS(CI.getArgOperand(0));
     const Function *StatepointFn =