[IR] Add LLVM IR support for target("aarch64.svcount") type.

[sdesmalen]

Summary

The C and C++ Language Extensions for AArch64 SME2 [1] adds a new type called
svcount_t which describes a predicate. This is not a predicate vector
mask, but rather a description of a predicate vector mask that can be
expanded into a mask using explicit instructions. The type is a scalable
opaque type.

To implement svcount_t type this patch uses the existing Target Extension Type
mechanism, but adds further support so that this type can be a scalable type.

AArch64 CodeGen support will follow in a separate patch.

[1] https://github.com/ARM-software/acle/pull/217

[nikic]

Any chance this can be implemented as an opaque type as introduced in https://reviews.llvm.org/D135202 instead? Providing a general mechanism for target-specific types is the purpose of opaque types, so it would be great if they work for this use case. cc @jcranmer-intel

[aemerson]

In D136861#3889474, @nikic wrote:

Any chance this can be implemented as an opaque type as introduced in https://reviews.llvm.org/D135202 instead? Providing a general mechanism for target-specific types is the purpose of opaque types, so it would be great if they work for this use case. cc @jcranmer-intel

Can this be implemented in the existing way? Otherwise users of -DCLANG_ENABLE_OPAQUE_POINTERS=OFF/-Xclang -no-opaque-pointers won't be able to use SME intrinsics.

[nikic]

In D136861#3889897, @aemerson wrote:

In D136861#3889474, @nikic wrote:

Any chance this can be implemented as an opaque type as introduced in https://reviews.llvm.org/D135202 instead? Providing a general mechanism for target-specific types is the purpose of opaque types, so it would be great if they work for this use case. cc @jcranmer-intel

Can this be implemented in the existing way? Otherwise users of -DCLANG_ENABLE_OPAQUE_POINTERS=OFF/-Xclang -no-opaque-pointers won't be able to use SME intrinsics.

Despite both having "opaque" in the name, opaque pointers and opaque types aren't really related. Opaque types would work even with -no-opaque-pointers.

[aemerson]

In D136861#3889901, @nikic wrote:

In D136861#3889897, @aemerson wrote:

In D136861#3889474, @nikic wrote:

Any chance this can be implemented as an opaque type as introduced in https://reviews.llvm.org/D135202 instead? Providing a general mechanism for target-specific types is the purpose of opaque types, so it would be great if they work for this use case. cc @jcranmer-intel

Can this be implemented in the existing way? Otherwise users of -DCLANG_ENABLE_OPAQUE_POINTERS=OFF/-Xclang -no-opaque-pointers won't be able to use SME intrinsics.

Despite both having "opaque" in the name, opaque pointers and opaque types aren't really related. Opaque types would work even with -no-opaque-pointers.

Ah ok, that's fine then. Although from looking at D135202 it doesn't look like the design has been settled yet? I don't think we should be writing patches upon speculative changes, so unless D135202 is going to land very soon I'd prefer we continued with the traditional approach.

[nikic]

In D136861#3890025, @aemerson wrote:

Ah ok, that's fine then. Although from looking at D135202 it doesn't look like the design has been settled yet? I don't think we should be writing patches upon speculative changes, so unless D135202 is going to land very soon I'd prefer we continued with the traditional approach.

Yeah, possibly. I'd suggest to still consider the possibility when you put up the RFC for this change, as it's likely going to be an easier sell if it doesn't require the addition of a new target-specific type.

[jcranmer-intel]

In D136861#3890025, @aemerson wrote:

Ah ok, that's fine then. Although from looking at D135202 it doesn't look like the design has been settled yet? I don't think we should be writing patches upon speculative changes, so unless D135202 is going to land very soon I'd prefer we continued with the traditional approach.

At a quick glance of this patch, this does seem like something that could be built on top of opaque types were they already landed, so it's at least worth considering how this type might be implemented as an opaque type. The thing that's the most unsettled in the design is effectively the communication of DataLayout-like type properties of target types, and while I hoped to have a solution to that coded up today, I didn't get enough time to do so.

[efriedma]

From the spec, svreinterpret_c(svreinterpret_b(x)) is equivalent to x, right? So you could just lower svcount_t to <vscale x 16 x i1>, but you want to avoid confusion with non-SME predicate vectors in LLVM IR?

[sdesmalen]

Refactored the patch to use the existing target("<customtype>") mechanism.

[sdesmalen]

Thanks for all the previous comments! I've rewritten the patch to use the new target-extension types, since that functionality has now landed. This made the patch a lot simpler. I've only had to add a new interface to check if the TargetExtType is scalable.

I will try to be a bit more responsive to comments this time around :)

In D136861#3900512, @efriedma wrote:

From the spec, svreinterpret_c(svreinterpret_b(x)) is equivalent to x, right? So you could just lower svcount_t to <vscale x 16 x i1>, but you want to avoid confusion with non-SME predicate vectors in LLVM IR?

We could let Clang emit the reinterpret cast, but we want the intrinsics to be correct for other front-ends as well think of e.g. MLIR. By giving it a proper type it becomes unambiguous what the format of the predicate value must be when passing it to the intrinsic.

[nikic]

llvm/lib/Transforms/Scalar/SROA.cpp

895 ↗

(On Diff #496098)

I think it would be more elegant to get the TypeSize return value here and check whether it is isScalable(). That would avoid the need to explicitly check for ScalableVectorType and scalable target extension types. (Feel free to pre-commit as an NFC change and reduce the diff here.)

TypeSize Size = DL.getTypeStoreSize(LI.getType());
if (Size.isScalable())
  return PI.setAborted(&LI);
return handleLoadOrStore(LI.getType(), LI, Offset, Size.getFixedValue(), LI.isVolatile());

[sdesmalen]

llvm/lib/Transforms/Scalar/SROA.cpp

895 ↗

(On Diff #496098)

That makes sense, thanks for the suggestion. I can do the same (look at allocated type size, rather than the type itself) for all other cases in this file as well.

[sdesmalen]

Split out SROA changes into rG462227f1150f as suggested, and rebased this patch.

[jcranmer-intel]

I'd ideally like to see discussion of this target extension type somewhere in documentation, but alas, AArch64 is one of the backends that lacks a dedicated target documentation page.

[jcranmer-intel]

llvm/lib/Transforms/InstCombine/InstCombineSelect.cpp

1703–1705 ↗

(On Diff #497588)

A better fix here, I think, is to add a test for the block below so that it only applies to integer or integer vector types.

[sdesmalen]

• Added description of the svcount type to AArch64SME.rst
• Use isIntOrIntVectorTy() in foldSelectInstWithICmp
• Added Type::isScalableTy() convenience function.

[sdesmalen]

@jcranmer-intel thanks for your review, I think I've addressed both your comments now.

[nikic]

llvm/include/llvm/IR/Type.h

191

It doesn't look like these new methods are actually used?

llvm/lib/Transforms/InstCombine/InstCombineSelect.cpp

1705 ↗

(On Diff #499202)

This could be committed separately.

[jcranmer-intel]

Thank you for adding documentation for target("aarch64.svcount"). Otherwise, the only other thing I would comment is the same thing that Nikita said with regards to the unused new methods.

[sdesmalen]

llvm/include/llvm/IR/Type.h

191

They are used in the patches that follow it (D143642 and D136862). I thought it made sense to add them to this patch, given that this patch adds the concept of scalable target extension types (with svcount being an instantiation of that). I'm happy to move the interfaces to the other patches if that has the preference.

[nikic]

llvm/include/llvm/IR/Type.h

191

I think it would be better to introduce them later, mainly because I'm not sure we really need them. I think checking isa<ScalabelVectorType> is an anti-pattern in most (but maybe not all) cases.

E.g. for the SCEV change I put up D144624 as an alternative which works on TypeSize only. I think something like this can usually be done (places that have to guard against scalable vectors are generally places that query TypeSize...)

[sdesmalen]

• Removed unused interfaces.
• Rebased after moving out change in foldSelectInstWithICmp.

[nikic]

LGTM from IR perspective. I assume this already has internal consensus on the ARM side.

llvm/docs/AArch64SME.rst

462 ↗

(On Diff #499876)

Probably select as well,

llvm/lib/IR/Type.cpp

791

Could drop the outer check while there is only one type...

[sdesmalen]

Thanks for the reviews! I've addressed the nits before committing the patch.

llvm/docs/LangRef.rst

 
 :Syntax:
 
 ::
 
       x86_mmx
 
 
+AArch64 Predicate-as-Counter Type
+"""""""""""""""""""""""""""""""""
+
+:Overview:
+
+The ``aarch64_svcount`` type represents the type of a predicate-as-counter value
+held in a AArch64 SVE predicate register. Such a value contains information
+about the number of active lanes, the element width and a bit that tells whether
+the generated mask should be inverted. Target-specific intrinsics should be used
+to move the aarch64_svcount value to/from a predicate vector.
+
+There are certain limitations on the type:
+* The type can be used for function parameters and return values.
+* The supported LLVM operations on this type are strictly limited to ``load``,
+  ``store``, ``phi`` and ``alloca`` instructions.
+
+The predicate-as-counter type is a scalable type.
+
+:Syntax:
+
+::
+
+      aarch64_svcount
+
+
 .. _t_pointer:
 
 Pointer Type
 """"""""""""
 
 :Overview:
 
 The pointer type ``ptr`` is used to specify memory locations. Pointers are

llvm/include/llvm/Bitcode/LLVMBitCodes.h

enum TypeCodes {
   TYPE_CODE_FUNCTION = 21, // FUNCTION: [vararg, retty, paramty x N]
 
   TYPE_CODE_TOKEN = 22, // TOKEN
 
   TYPE_CODE_BFLOAT = 23,  // BRAIN FLOATING POINT
   TYPE_CODE_X86_AMX = 24, // X86 AMX
 
   TYPE_CODE_OPAQUE_POINTER = 25, // OPAQUE_POINTER: [addrspace]
+  TYPE_CODE_AARCH64_SVCOUNT = 26, // AArch64 predicate-as-counter
 };
 
 enum OperandBundleTagCode {
   OPERAND_BUNDLE_TAG = 1, // TAG: [strchr x N]
 };
 
 enum SyncScopeNameCode {
   SYNC_SCOPE_NAME = 1,

llvm/include/llvm/CodeGen/ValueTypes.td

 def x86mmx    : ValueType<64,   179>;  // X86 MMX value
 def FlagVT    : ValueType<0,    180>;  // Pre-RA sched glue
 def isVoid    : ValueType<0,    181>;  // Produces no value
 def untyped   : ValueType<8,    182>;  // Produces an untyped value
 def funcref   : ValueType<0,    183>;  // WebAssembly's funcref type
 def externref : ValueType<0,    184>;  // WebAssembly's externref type
 def x86amx    : ValueType<8192, 185>;  // X86 AMX value
 def i64x8     : ValueType<512,  186>;  // 8 Consecutive GPRs (AArch64)
+def aarch64svcount
+              : ValueType<16,   187>;  // AArch64 predicate-as-counter
 
 def token      : ValueType<0, 248>;  // TokenTy
 def MetadataVT : ValueType<0, 249>;  // Metadata
 
 // Pseudo valuetype mapped to the current pointer size to any address space.
 // Should only be used in TableGen.
 def iPTRAny    : ValueType<0, 250>;
 

llvm/include/llvm/IR/DataLayout.h

inline TypeSize DataLayout::getTypeSizeInBits(Type *Ty) const {
   case Type::FP128TyID:
     return TypeSize::Fixed(128);
   case Type::X86_AMXTyID:
     return TypeSize::Fixed(8192);
   // In memory objects this is always aligned to a higher boundary, but
   // only 80 bits contain information.
   case Type::X86_FP80TyID:
     return TypeSize::Fixed(80);
+  case Type::AArch64SvcountTyID:
+    return TypeSize::Scalable(16);
   case Type::FixedVectorTyID:
   case Type::ScalableVectorTyID: {
     VectorType *VTy = cast<VectorType>(Ty);
     auto EltCnt = VTy->getElementCount();
     uint64_t MinBits = EltCnt.getKnownMinValue() *
                        getTypeSizeInBits(VTy->getElementType()).getFixedSize();
     return TypeSize(MinBits, EltCnt.isScalable());
   }
   default:
     llvm_unreachable("DataLayout::getTypeSizeInBits(): Unsupported type");
   }
 }
 
 } // end namespace llvm
 
 #endif // LLVM_IR_DATALAYOUT_H

llvm/include/llvm/IR/Type.h

enum TypeID {
     X86_FP80TyID,  ///< 80-bit floating point type (X87)
     FP128TyID,     ///< 128-bit floating point type (112-bit significand)
     PPC_FP128TyID, ///< 128-bit floating point type (two 64-bits, PowerPC)
     VoidTyID,      ///< type with no size
     LabelTyID,     ///< Labels
     MetadataTyID,  ///< Metadata
     X86_MMXTyID,   ///< MMX vectors (64 bits, X86 specific)
     X86_AMXTyID,   ///< AMX vectors (8192 bits, X86 specific)
+    AArch64SvcountTyID, /// AArch64 predicate-as-counter (vscale x 2bits)
     TokenTyID,     ///< Tokens
 
     // Derived types... see DerivedTypes.h file.
     IntegerTyID,        ///< Arbitrary bit width integers
     FunctionTyID,       ///< Functions
     PointerTyID,        ///< Pointers
     StructTyID,         ///< Structures
     ArrayTyID,          ///< Arrays
public:
   const fltSemantics &getFltSemantics() const;
 
   /// Return true if this is X86 MMX.
   bool isX86_MMXTy() const { return getTypeID() == X86_MMXTyID; }
 
   /// Return true if this is X86 AMX.
   bool isX86_AMXTy() const { return getTypeID() == X86_AMXTyID; }
 
+  /// Return true if this is a AArch64 Predicate-as-counter type.
+  bool isAArch64SvcountTy() const { return getTypeID() == AArch64SvcountTyID; }
+
   /// Return true if this is a FP type or a vector of FP.
   bool isFPOrFPVectorTy() const { return getScalarType()->isFloatingPointTy(); }
 
   /// Return true if this is 'label'.
   bool isLabelTy() const { return getTypeID() == LabelTyID; }
 
   /// Return true if this is 'metadata'.
   bool isMetadataTy() const { return getTypeID() == MetadataTyID; }
 
   /// Return true if this is 'token'.
   bool isTokenTy() const { return getTypeID() == TokenTyID; }
 
   /// True if this is an instance of IntegerType.
public:
   static Type *getFloatTy(LLVMContext &C);
   static Type *getDoubleTy(LLVMContext &C);
   static Type *getMetadataTy(LLVMContext &C);
   static Type *getX86_FP80Ty(LLVMContext &C);
   static Type *getFP128Ty(LLVMContext &C);
   static Type *getPPC_FP128Ty(LLVMContext &C);
   static Type *getX86_MMXTy(LLVMContext &C);
   static Type *getX86_AMXTy(LLVMContext &C);
+  static Type *getAArch64SvcountTy(LLVMContext &C);
   static Type *getTokenTy(LLVMContext &C);
   static IntegerType *getIntNTy(LLVMContext &C, unsigned N);
   static IntegerType *getInt1Ty(LLVMContext &C);
   static IntegerType *getInt8Ty(LLVMContext &C);
   static IntegerType *getInt16Ty(LLVMContext &C);
   static IntegerType *getInt32Ty(LLVMContext &C);
   static IntegerType *getInt64Ty(LLVMContext &C);
   static IntegerType *getInt128Ty(LLVMContext &C);

llvm/lib/AsmParser/LLLexer.cpp

#define TYPEKEYWORD(STR, LLVMTY)                                               \
   TYPEKEYWORD("double",    Type::getDoubleTy(Context));
   TYPEKEYWORD("x86_fp80",  Type::getX86_FP80Ty(Context));
   TYPEKEYWORD("fp128",     Type::getFP128Ty(Context));
   TYPEKEYWORD("ppc_fp128", Type::getPPC_FP128Ty(Context));
   TYPEKEYWORD("label",     Type::getLabelTy(Context));
   TYPEKEYWORD("metadata",  Type::getMetadataTy(Context));
   TYPEKEYWORD("x86_mmx",   Type::getX86_MMXTy(Context));
   TYPEKEYWORD("x86_amx",   Type::getX86_AMXTy(Context));
+  TYPEKEYWORD("aarch64_svcount", Type::getAArch64SvcountTy(Context));
   TYPEKEYWORD("token",     Type::getTokenTy(Context));
 
   if (Keyword == "ptr") {
     // setOpaquePointers() must be called before creating any pointer types.
     if (!Context.hasSetOpaquePointersValue()) {
       Context.setOpaquePointers(true);
     } else if (Context.supportsTypedPointers()) {
       Warning("ptr type is only supported in -opaque-pointers mode");

llvm/lib/Bitcode/Reader/BitcodeAnalyzer.cpp

default:
       STRINGIFY_CODE(TYPE_CODE, HALF)
       STRINGIFY_CODE(TYPE_CODE, ARRAY)
       STRINGIFY_CODE(TYPE_CODE, VECTOR)
       STRINGIFY_CODE(TYPE_CODE, X86_FP80)
       STRINGIFY_CODE(TYPE_CODE, FP128)
       STRINGIFY_CODE(TYPE_CODE, PPC_FP128)
       STRINGIFY_CODE(TYPE_CODE, METADATA)
       STRINGIFY_CODE(TYPE_CODE, X86_MMX)
+      STRINGIFY_CODE(TYPE_CODE, AARCH64_SVCOUNT)
       STRINGIFY_CODE(TYPE_CODE, STRUCT_ANON)
       STRINGIFY_CODE(TYPE_CODE, STRUCT_NAME)
       STRINGIFY_CODE(TYPE_CODE, STRUCT_NAMED)
       STRINGIFY_CODE(TYPE_CODE, FUNCTION)
       STRINGIFY_CODE(TYPE_CODE, TOKEN)
       STRINGIFY_CODE(TYPE_CODE, BFLOAT)
     }
 

llvm/lib/Bitcode/Reader/BitcodeReader.cpp

case bitc::TYPE_CODE_METADATA:  // METADATA
       ResultTy = Type::getMetadataTy(Context);
       break;
     case bitc::TYPE_CODE_X86_MMX:   // X86_MMX
       ResultTy = Type::getX86_MMXTy(Context);
       break;
     case bitc::TYPE_CODE_X86_AMX:   // X86_AMX
       ResultTy = Type::getX86_AMXTy(Context);
       break;
+    case bitc::TYPE_CODE_AARCH64_SVCOUNT: // AArch64Svcount
+      ResultTy = Type::getAArch64SvcountTy(Context);
+      break;
     case bitc::TYPE_CODE_TOKEN:     // TOKEN
       ResultTy = Type::getTokenTy(Context);
       break;
     case bitc::TYPE_CODE_INTEGER: { // INTEGER: [width]
       if (Record.empty())
         return error("Invalid integer record");
 
       uint64_t NumBits = Record[0];

llvm/lib/Bitcode/Writer/BitcodeWriter.cpp

for (Type *T : TypeList) {
     case Type::DoubleTyID:    Code = bitc::TYPE_CODE_DOUBLE;    break;
     case Type::X86_FP80TyID:  Code = bitc::TYPE_CODE_X86_FP80;  break;
     case Type::FP128TyID:     Code = bitc::TYPE_CODE_FP128;     break;
     case Type::PPC_FP128TyID: Code = bitc::TYPE_CODE_PPC_FP128; break;
     case Type::LabelTyID:     Code = bitc::TYPE_CODE_LABEL;     break;
     case Type::MetadataTyID:  Code = bitc::TYPE_CODE_METADATA;  break;
     case Type::X86_MMXTyID:   Code = bitc::TYPE_CODE_X86_MMX;   break;
     case Type::X86_AMXTyID:   Code = bitc::TYPE_CODE_X86_AMX;   break;
+    case Type::AArch64SvcountTyID:
+      Code = bitc::TYPE_CODE_AARCH64_SVCOUNT;
+      break;
     case Type::TokenTyID:     Code = bitc::TYPE_CODE_TOKEN;     break;
     case Type::IntegerTyID:
       // INTEGER: [width]
       Code = bitc::TYPE_CODE_INTEGER;
       TypeVals.push_back(cast<IntegerType>(T)->getBitWidth());
       break;
     case Type::PointerTyID: {
       PointerType *PTy = cast<PointerType>(T);

llvm/lib/IR/AsmWriter.cpp

void TypePrinting::print(Type *Ty, raw_ostream &OS) {
   case Type::DoubleTyID:    OS << "double"; return;
   case Type::X86_FP80TyID:  OS << "x86_fp80"; return;
   case Type::FP128TyID:     OS << "fp128"; return;
   case Type::PPC_FP128TyID: OS << "ppc_fp128"; return;
   case Type::LabelTyID:     OS << "label"; return;
   case Type::MetadataTyID:  OS << "metadata"; return;
   case Type::X86_MMXTyID:   OS << "x86_mmx"; return;
   case Type::X86_AMXTyID:   OS << "x86_amx"; return;
+  case Type::AArch64SvcountTyID:
+    OS << "aarch64_svcount";
+    return;
   case Type::TokenTyID:     OS << "token"; return;
   case Type::IntegerTyID:
     OS << 'i' << cast<IntegerType>(Ty)->getBitWidth();
     return;
 
   case Type::FunctionTyID: {
     FunctionType *FTy = cast<FunctionType>(Ty);
     print(FTy->getReturnType(), OS);

llvm/lib/IR/LLVMContextImpl.h

#include "llvm/IR/Metadata.def"
   ConstantUniqueMap<InlineAsm> InlineAsms;
 
   ConstantInt *TheTrueVal = nullptr;
   ConstantInt *TheFalseVal = nullptr;
 
   // Basic type instances.
   Type VoidTy, LabelTy, HalfTy, BFloatTy, FloatTy, DoubleTy, MetadataTy,
       TokenTy;
-  Type X86_FP80Ty, FP128Ty, PPC_FP128Ty, X86_MMXTy, X86_AMXTy;
+  Type X86_FP80Ty, FP128Ty, PPC_FP128Ty, X86_MMXTy, X86_AMXTy, AArch64SvcountTy;
   IntegerType Int1Ty, Int8Ty, Int16Ty, Int32Ty, Int64Ty, Int128Ty;
 
   std::unique_ptr<ConstantTokenNone> TheNoneToken;
 
   BumpPtrAllocator Alloc;
   UniqueStringSaver Saver{Alloc};
 
   DenseMap<unsigned, IntegerType *> IntegerTypes;

llvm/lib/IR/LLVMContextImpl.cpp

 LLVMContextImpl::LLVMContextImpl(LLVMContext &C)
     : DiagHandler(std::make_unique<DiagnosticHandler>()),
       VoidTy(C, Type::VoidTyID), LabelTy(C, Type::LabelTyID),
       HalfTy(C, Type::HalfTyID), BFloatTy(C, Type::BFloatTyID),
       FloatTy(C, Type::FloatTyID), DoubleTy(C, Type::DoubleTyID),
       MetadataTy(C, Type::MetadataTyID), TokenTy(C, Type::TokenTyID),
       X86_FP80Ty(C, Type::X86_FP80TyID), FP128Ty(C, Type::FP128TyID),
       PPC_FP128Ty(C, Type::PPC_FP128TyID), X86_MMXTy(C, Type::X86_MMXTyID),
-      X86_AMXTy(C, Type::X86_AMXTyID), Int1Ty(C, 1), Int8Ty(C, 8),
+      X86_AMXTy(C, Type::X86_AMXTyID),
+      AArch64SvcountTy(C, Type::AArch64SvcountTyID), Int1Ty(C, 1), Int8Ty(C, 8),
       Int16Ty(C, 16), Int32Ty(C, 32), Int64Ty(C, 64), Int128Ty(C, 128) {
   if (OpaquePointersCL.getNumOccurrences()) {
     OpaquePointers = OpaquePointersCL;
   }
 }
 
 LLVMContextImpl::~LLVMContextImpl() {
   // NOTE: We need to delete the contents of OwnedModules, but Module's dtor

llvm/lib/IR/Type.cpp

 Type *Type::getDoubleTy(LLVMContext &C) { return &C.pImpl->DoubleTy; }
 Type *Type::getMetadataTy(LLVMContext &C) { return &C.pImpl->MetadataTy; }
 Type *Type::getTokenTy(LLVMContext &C) { return &C.pImpl->TokenTy; }
 Type *Type::getX86_FP80Ty(LLVMContext &C) { return &C.pImpl->X86_FP80Ty; }
 Type *Type::getFP128Ty(LLVMContext &C) { return &C.pImpl->FP128Ty; }
 Type *Type::getPPC_FP128Ty(LLVMContext &C) { return &C.pImpl->PPC_FP128Ty; }
 Type *Type::getX86_MMXTy(LLVMContext &C) { return &C.pImpl->X86_MMXTy; }
 Type *Type::getX86_AMXTy(LLVMContext &C) { return &C.pImpl->X86_AMXTy; }
-
+Type *Type::getAArch64SvcountTy(LLVMContext &C) {
+  return &C.pImpl->AArch64SvcountTy;
+}
 IntegerType *Type::getInt1Ty(LLVMContext &C) { return &C.pImpl->Int1Ty; }
 IntegerType *Type::getInt8Ty(LLVMContext &C) { return &C.pImpl->Int8Ty; }
 IntegerType *Type::getInt16Ty(LLVMContext &C) { return &C.pImpl->Int16Ty; }
 IntegerType *Type::getInt32Ty(LLVMContext &C) { return &C.pImpl->Int32Ty; }
 IntegerType *Type::getInt64Ty(LLVMContext &C) { return &C.pImpl->Int64Ty; }
 IntegerType *Type::getInt128Ty(LLVMContext &C) { return &C.pImpl->Int128Ty; }
 
 IntegerType *Type::getIntNTy(LLVMContext &C, unsigned N) {

 bool PointerType::isValidElementType(Type *ElemTy) {
   return !ElemTy->isVoidTy() && !ElemTy->isLabelTy() &&
          !ElemTy->isMetadataTy() && !ElemTy->isTokenTy() &&
          !ElemTy->isX86_AMXTy();
 }
 
 bool PointerType::isLoadableOrStorableType(Type *ElemTy) {
   return isValidElementType(ElemTy) && !ElemTy->isFunctionTy();
 }

llvm/test/Assembler/aarch64_svcount.ll

+; RUN: llvm-as < %s | llvm-dis | FileCheck %s
+; RUN: verify-uselistorder %s
+; Basic smoke test for aarch64_svcount type.
+
+define aarch64_svcount  @func1(aarch64_svcount %A) {
+; CHECK-LABEL: @func1
+; CHECK:  ret aarch64_svcount %A
+  ret aarch64_svcount %A
+}
+
+define aarch64_svcount @func2(aarch64_svcount %A) {
+; CHECK-LABEL: @func2
+; CHECK:  %1 = call aarch64_svcount @func1(aarch64_svcount %A)
+; CHECK-NEXT:  ret aarch64_svcount %1
+  %1 = call aarch64_svcount @func1(aarch64_svcount %A);
+  ret aarch64_svcount %1
+}