IR: Conservatively verify inalloca arguments

[majnemer]

Summary

Try to spot obvious mismatches with inalloca use.

[rnk]

LGTM

Chandler was pushing to put this in the lint pass, but I don't agree. If he feels strongly, he can argue for it in post-commit review.

lib/IR/Verifier.cpp

865

stray bit

1499

s/If/if/

[majnemer]

Closed by commit rL207676 (authored by @majnemer).

lib/IR/Verifier.cpp

for (unsigned i = 0, e = Attrs.getNumSlots(); i != e; ++i) {
     }
 
     if (Attrs.hasAttribute(Idx, Attribute::StructRet))
       Assert1(Idx == 1, "Attribute sret is not on first parameter!", V);
 
     if (Attrs.hasAttribute(Idx, Attribute::InAlloca)) {
       Assert1(Idx == FT->getNumParams(),
               "inalloca isn't on the last parameter!", V);
+      //
     }
   }
 
   if (!Attrs.hasAttributes(AttributeSet::FunctionIndex))
     return;
 
   VerifyAttributeTypes(Attrs, AttributeSet::FunctionIndex, true, V);
 
void Verifier::VerifyCallSite(CallSite CS) {
   AttributeSet Attrs = CS.getAttributes();
 
   Assert1(VerifyAttributeCount(Attrs, CS.arg_size()),
           "Attribute after last parameter!", I);
 
   // Verify call attributes.
   VerifyFunctionAttrs(FTy, Attrs, I);
 
+  // Conservatively check the inalloca argument.
+  // We have a bug If we can find that there is an underlying alloca without
+  // inalloca.
+  if (CS.hasInAllocaArgument()) {
+    Value *InAllocaArg = CS.getArgument(FTy->getNumParams() - 1);
+    if (auto AI = dyn_cast<AllocaInst>(InAllocaArg->stripInBoundsOffsets()))
+      Assert2(AI->isUsedWithInAlloca(),
+              "inalloca argument for call has mismatched alloca", AI, I);
+  }
+
   if (FTy->isVarArg()) {
     // FIXME? is 'nest' even legal here?
     bool SawNest = false;
     bool SawReturned = false;
 
     for (unsigned Idx = 1; Idx < 1 + FTy->getNumParams(); ++Idx) {
       if (Attrs.hasAttribute(Idx, Attribute::Nest))
         SawNest = true;

test/Transforms/ArgumentPromotion/inalloca.ll

entry:
   ret i32 %r
 }
 ; CHECK-LABEL: define internal i32 @f
 ; CHECK-NOT: load
 ; CHECK: ret
 
 define i32 @main() {
 entry:
-  %S = alloca %struct.ss
+  %S = alloca inalloca %struct.ss
   %f0 = getelementptr %struct.ss* %S, i32 0, i32 0
   %f1 = getelementptr %struct.ss* %S, i32 0, i32 1
   store i32 1, i32* %f0, align 4
   store i32 2, i32* %f1, align 4
   %r = call i32 @f(%struct.ss* inalloca %S)
   ret i32 %r
 }
 ; CHECK-LABEL: define i32 @main
 ; CHECK-NOT: load
 ; CHECK: ret
 
 ; Argpromote can't promote %a because of the icmp use.
 define internal i1 @g(%struct.ss* %a, %struct.ss* inalloca %b) nounwind  {
 ; CHECK: define internal i1 @g(%struct.ss* %a, %struct.ss* inalloca %b)
 entry:
   %c = icmp eq %struct.ss* %a, %b
   ret i1 %c
 }
 
 define i32 @test() {
 entry:
-  %S = alloca %struct.ss
+  %S = alloca inalloca %struct.ss
   %c = call i1 @g(%struct.ss* %S, %struct.ss* inalloca %S)
 ; CHECK: call i1 @g(%struct.ss* %S, %struct.ss* inalloca %S)
   ret i32 0
 }

test/Transforms/InstCombine/call-cast-target-inalloca.ll

 ; RUN: opt < %s -instcombine -S | FileCheck %s
 
 target datalayout = "e-p:32:32"
 target triple = "i686-pc-linux-gnu"
 
 declare void @takes_i32(i32)
 declare void @takes_i32_inalloca(i32* inalloca)
 
 define void @f() {
 ; CHECK-LABEL: define void @f()
-  %args = alloca i32
+  %args = alloca inalloca i32
   call void bitcast (void (i32)* @takes_i32 to void (i32*)*)(i32* inalloca %args)
 ; CHECK: call void bitcast
   ret void
 }
 
 define void @g() {
 ; CHECK-LABEL: define void @g()
   call void bitcast (void (i32*)* @takes_i32_inalloca to void (i32)*)(i32 0)
 ; CHECK: call void bitcast
   ret void
 }

test/Verifier/inalloca3.ll

+; RUN: not llvm-as %s -o /dev/null 2>&1 | FileCheck %s
+
+
+declare void @doit(i64* inalloca %a)
+
+define void @a() {
+entry:
+  %a = alloca [2 x i32]
+  %b = bitcast [2 x i32]* %a to i64*
+  call void @doit(i64* inalloca %b)
+; CHECK: inalloca argument for call has mismatched alloca
+  ret void
+}