Handle indirect calls in preallocated verification

[aeubanks]

Summary

getCalledFunction() returns null for indirect function invocations.

[rnk]

lgtm

One thing you may have noticed is that LLVM has strange behavior for looking at attributes at the call site. Doing that can sometimes look at attributes on the callee if the call is direct. This makes sense for optimization hints (readonly, argmemonly etc), but not so much for ABI attributes.

llvm/test/Verifier/preallocated-valid.ll

21

This could be fragile to optimizations. I would probably take this as a parameter:

define void @preallocated_indirect(void (i32*)* %f) {
...

It's a bit arbitrary, but I like it when the IR looks like a plausible program.

llvm/lib/IR/Verifier.cpp

case Intrinsic::call_preallocated_setup: {
     Assert(NumArgs != nullptr,
            "llvm.call.preallocated.setup argument must be a constant");
     bool FoundCall = false;
     for (User *U : Call.users()) {
       auto *UseCall = dyn_cast<CallBase>(U);
       Assert(UseCall != nullptr,
              "Uses of llvm.call.preallocated.setup must be calls");
       const Function *Fn = UseCall->getCalledFunction();
-      if (Fn->getIntrinsicID() == Intrinsic::call_preallocated_arg) {
+      if (Fn && Fn->getIntrinsicID() == Intrinsic::call_preallocated_arg) {
         auto *AllocArgIndex = dyn_cast<ConstantInt>(UseCall->getArgOperand(1));
         Assert(AllocArgIndex != nullptr,
                "llvm.call.preallocated.alloc arg index must be a constant");
         auto AllocArgIndexInt = AllocArgIndex->getValue();
         Assert(AllocArgIndexInt.sge(0) &&
                    AllocArgIndexInt.slt(NumArgs->getValue()),
                "llvm.call.preallocated.alloc arg index must be between 0 and "
                "corresponding "
                "llvm.call.preallocated.setup's argument count");
       } else {
         Assert(!FoundCall, "Can have at most one call corresponding to a "
                            "llvm.call.preallocated.setup");
         FoundCall = true;
         size_t NumPreallocatedArgs = 0;
-        for (auto &Arg : Fn->args()) {
-          if (Arg.hasAttribute(Attribute::Preallocated)) {
+        for (unsigned i = 0; i < UseCall->getNumArgOperands(); i++) {
+          if (UseCall->paramHasAttr(i, Attribute::Preallocated)) {
             ++NumPreallocatedArgs;
           }
         }
         Assert(NumArgs->equalsInt(NumPreallocatedArgs),
                "llvm.call.preallocated.setup arg size must be equal to number "
                "of preallocated arguments "
                "at call site",
                Call, *UseCall);

llvm/test/Verifier/preallocated-valid.ll

 ; RUN: opt -S %s -verify
 
 declare token @llvm.call.preallocated.setup(i32)
 declare i8* @llvm.call.preallocated.arg(token, i32)
 
 declare void @foo1(i32* preallocated(i32))
 declare void @foo2(i32* preallocated(i32), i32*, i32* preallocated(i32))
 
 define void @preallocated() {
     %cs = call token @llvm.call.preallocated.setup(i32 1)
     %x = call i8* @llvm.call.preallocated.arg(token %cs, i32 0) preallocated(i32)
     %y = bitcast i8* %x to i32*
     call void @foo1(i32* preallocated(i32) %y) ["preallocated"(token %cs)]
     ret void
 }
 
+define void @preallocated_indirect() {
+    %cs = call token @llvm.call.preallocated.setup(i32 1)
+    %x = call i8* @llvm.call.preallocated.arg(token %cs, i32 0) preallocated(i32)
+    %y = bitcast i8* %x to i32*
+    %f = bitcast void (i32*)* @foo1 to void (i32*)*
+    call void %f(i32* preallocated(i32) %y) ["preallocated"(token %cs)]
+    ret void
+}
+
 define void @preallocated_setup_without_call() {
     %cs = call token @llvm.call.preallocated.setup(i32 1)
     %a0 = call i8* @llvm.call.preallocated.arg(token %cs, i32 0) preallocated(i32)
     ret void
 }
 
 define void @preallocated_num_args() {
     %cs = call token @llvm.call.preallocated.setup(i32 2)
     %x = call i8* @llvm.call.preallocated.arg(token %cs, i32 0) preallocated(i32)
     %x1 = bitcast i8* %x to i32*
     %y = call i8* @llvm.call.preallocated.arg(token %cs, i32 1) preallocated(i32)
     %y1 = bitcast i8* %y to i32*
     %a = inttoptr i32 0 to i32*
     call void @foo2(i32* preallocated(i32) %x1, i32* %a, i32* preallocated(i32) %y1) ["preallocated"(token %cs)]
     ret void
 }