Rename to CanBeLocal. Check byval arguments.

Author: jayfoad

llvm/include/llvm/IR/DerivedTypes.h

@@ -769,8 +769,9 @@ class TargetExtType : public Type {
     HasZeroInit = 1U << 0,
     /// This type may be used as the value type of a global variable.
     CanBeGlobal = 1U << 1,
-    /// This type may be used as the allocated type of an alloca instruction.
-    CanBeAlloca = 1U << 2,
+    /// This type may be allocated on the stack, either as the allocated type
+    // of an alloca instruction or as a byval function parameter.
+    CanBeLocal = 1U << 2,
   };
 
   /// Returns true if the target extension type contains the given property.

llvm/lib/IR/Type.cpp

@@ -827,13 +827,13 @@ static TargetTypeInfo getTargetTypeInfo(const TargetExtType *Ty) {
   if (Name.starts_with("spirv."))
     return TargetTypeInfo(PointerType::get(C, 0), TargetExtType::HasZeroInit,
                           TargetExtType::CanBeGlobal,
-                          TargetExtType::CanBeAlloca);
+                          TargetExtType::CanBeLocal);
 
   // Opaque types in the AArch64 name space.
   if (Name == "aarch64.svcount")
     return TargetTypeInfo(ScalableVectorType::get(Type::getInt1Ty(C), 16),
                           TargetExtType::HasZeroInit,
-                          TargetExtType::CanBeAlloca);
+                          TargetExtType::CanBeLocal);
 
   return TargetTypeInfo(Type::getVoidTy(C));
 }

llvm/lib/IR/Verifier.cpp

@@ -2021,6 +2021,12 @@ void Verifier::verifyParameterAttrs(AttributeSet Attrs, Type *Ty,
       SmallPtrSet<Type *, 4> Visited;
       Check(Attrs.getByValType()->isSized(&Visited),
             "Attribute 'byval' does not support unsized types!", V);
+      // Check if it's a target extension type that disallows being used on the
+      // stack.
+      if (auto *TTy = dyn_cast<TargetExtType>(Attrs.getByValType())) {
+        Check(TTy->hasProperty(TargetExtType::CanBeLocal),
+              "'byval' argument has illegal target extension type", V);
+      }
       Check(DL.getTypeAllocSize(Attrs.getByValType()).getKnownMinValue() <
                 (1ULL << 32),
             "huge 'byval' arguments are unsupported", V);
@@ -4285,10 +4291,10 @@ void Verifier::visitAllocaInst(AllocaInst &AI) {
   SmallPtrSet<Type*, 4> Visited;
   Check(AI.getAllocatedType()->isSized(&Visited),
         "Cannot allocate unsized type", &AI);
-  // Check if it's a target extension type that disallows being used in an
-  // alloca.
+  // Check if it's a target extension type that disallows being used on the
+  // stack.
   if (auto *TTy = dyn_cast<TargetExtType>(AI.getAllocatedType())) {
-    Check(TTy->hasProperty(TargetExtType::CanBeAlloca),
+    Check(TTy->hasProperty(TargetExtType::CanBeLocal),
           "Alloca has illegal target extension type", &AI);
   }
   Check(AI.getArraySize()->getType()->isIntegerTy(),

llvm/test/Assembler/target-type-properties.ll

@@ -2,6 +2,7 @@
 ; RUN: not llvm-as < %t/zeroinit-error.ll -o /dev/null 2>&1 | FileCheck --check-prefix=CHECK-ZEROINIT %s
 ; RUN: not llvm-as < %t/global-var.ll -o /dev/null 2>&1 | FileCheck --check-prefix=CHECK-GLOBALVAR %s
 ; RUN: not llvm-as < %t/alloca.ll -o /dev/null 2>&1 | FileCheck --check-prefix=CHECK-ALLOCA %s
+; RUN: not llvm-as < %t/byval.ll -o /dev/null 2>&1 | FileCheck --check-prefix=CHECK-BYVAL %s
 ; Check target extension type properties are verified in the assembler.
 
 ;--- zeroinit-error.ll
@@ -22,3 +23,7 @@ define void @foo() {
 ; CHECK-ALLOCA: Alloca has illegal target extension type
   ret void
 }
+
+;--- byval.ll
+declare void @foo(ptr byval(target("spirv.Image")))
+; CHECK-BYVAL: 'byval' argument has illegal target extension type