[PATCH 2/4][Sema][AArch64] Add semantics for arm_sve_vector_bits attribute

[c-rhodes]

Summary

This patch implements semantics for the 'arm_sve_vector_bits' type
attribute, defined by the Arm C Language Extensions (ACLE) for SVE [1].
The purpose of this attribute is to define fixed-length (VLST) versions
of existing sizeless types (VLAT).

Implemented in this patch is the the behaviour described in section 3.7.3.2
and minimal parts of sections 3.7.3.3 and 3.7.3.4, this includes:

• Defining VLST globals, structs, unions, and local variables
• Implicit casting between VLAT <=> VLST.
• Diagnosis of ill-formed conditional expressions of the form:
  
  C ? E1 : E2
  
  where E1 is a VLAT type and E2 is a VLST, or vice-versa. This avoids any ambiguity about the nature of the result type (i.e is it sized or sizeless).
• For vectors:
  • sizeof(VLST) == N/8
  • alignof(VLST) == 16
• For predicates:
  • sizeof(VLST) == N/64
  • alignof(VLST) == 2

VLSTs have the same representation as VLATs in the AST but are wrapped
with a TypeAttribute. Scalable types are currently emitted in the IR for
uses such as globals and structs which don't support these types, this
is addressed in the next patch with codegen, where VLSTs are lowered to
sized arrays for globals, structs / unions and arrays.

Not implemented in this patch is the behaviour guarded by the feature
macros:

• __ARM_FEATURE_SVE_VECTOR_OPERATORS
• __ARM_FEATURE_SVE_PREDICATE_OPERATORS

As such, the GNU attribute((vector_size)) extension is not available
and operators such as binary '+' are not supported for VLSTs. Support
for this is intended to be addressed by later patches.

[1] https://developer.arm.com/documentation/100987/latest

[sdesmalen]

clang/include/clang/Basic/Attr.td

1577

nit: Can you add a comment saying why these are undocumented (and have no spellings)

clang/lib/AST/ASTContext.cpp

1872

Should this function just return unsigned and error when it doesn't have any of the ArmSveVectorBits attributes?
i.e. if isVLST() returns true, then it is an error if it doesn't have any of the attributes handled below.

1897

nit: I find this name a bit misleading, because I would expect the (ARM_SVE_VECTOR_) bits to be the same regardless of the type. Maybe rename this to getBitwidthForAttributedSveType ?

clang/lib/Sema/SemaType.cpp

7761–7766

Unrelated changes?

7816

If we only support power-of-two for now, we should only have an llvm_unreachable if we prevent parsing any of the other widths (and give an appropriate diagnostic saying those widths are not yet supported).

clang/test/Sema/attr-arm-sve-vector-bits.c

64

nit: For the tests that you've added below, can you add more elaborate comments explaining what you're trying to test?
e.g. here I assume that sizeless globals are otherwise not allowed, but they are when attributed with arm_sve_vector_bits. It would be good to have that explained a bit.

99

Is this diagnostic produced because of any code-changes in this patch?

155

nit: Is it necessary to test this for all the types?

225

nit: s/Test call/Test the scalable and fixed-width annotated types can be used interchangeably/

[aaron.ballman]

clang/include/clang/Basic/Attr.td

1577

Also, I think these are all missing let SemaHandler = 0; and let ASTNode = 0;

Is there a reason why we need N different type attributes instead of having a single type attribute which encodes the N as an argument? I think this may simplify the patch somewhat as you no longer need to switch over N as much.

[sdesmalen]

clang/include/clang/Basic/Attr.td

1577

Is there a reason why we need N different type attributes instead of having a single type attribute which encodes the N as an argument?

AIUI this was a workaround for getting the value of N from an AttributedType, because this only has getAttrKind to return the attribute kind, but no way to get the corresponding argument/value. This seemed like a simple way to do that without having to create a new subclass for Type and having to support that in various places. Is the latter the approach you were thinking of? (or is there perhaps a simpler way?)

[c-rhodes]

clang/include/clang/Basic/Attr.td

1577

Also, I think these are all missing let SemaHandler = 0; and let ASTNode = 0;

Good to know. In SemaType I'm doing CurType = State.getAttributedType(A, CurType, CurType); which gives an AttributedType in the AST, should I still set let ASTNode = 0; in this case?

Is there a reason why we need N different type attributes instead of having a single type attribute which encodes the N as an argument?

As Sander mentioned, it seemed like the easiest solution, interested to know if there's a better approach however

[aaron.ballman]

clang/include/clang/Basic/Attr.td

1577

I was thinking specifically of creating a new Type subclass and supporting it rather than adding 5 new attributes that only vary by a bit-width (which means there's likely to be a 6th someday). It's not immediately clear to me whether that's a really big ask for little gain or not, though.

1577

Ah, you're right, we may still need ASTNode to be kept around for that, good call.

[c-rhodes]

Changes:

• Documented internal type attributes.
• Set ASTNode = 0 on user-facing ArmSveVectorBitsAttr as the internal type attrs are used in the AST. Also removed the case for this from TypePrinter.
• getSveVectorWidth now returns an unsigned. Added an unreachable if T has no attrs.
• s/getArmSveVectorBits/getBitwidthForAttributedSveType. Also now returns an unsigned and asserts if !T->isVLST().
• Add a few comments in test and reduced them a little so we dont tell all types for structs / unions etc.

[c-rhodes]

clang/include/clang/Basic/Attr.td

1577

Also, I think these are all missing let SemaHandler = 0; and let ASTNode = 0;

I've added let SemaHandler = 0; for the internal types and let ASTNode = 0; for the user-facing attr.

clang/lib/AST/ASTContext.cpp

1897

nit: I find this name a bit misleading, because I would expect the (ARM_SVE_VECTOR_) bits to be the same regardless of the type. Maybe rename this to getBitwidthForAttributedSveType ?

You're right, poor choice of name, I've updated it

clang/lib/Sema/SemaType.cpp

7761–7766

Unrelated changes?

TypeProcessingState &State is required to create an attributed type and Sema is attached to this so I removed it from the interface. This is inline with other attributed type handlers. I pulled S.Context out as it's used frequently.

7816

If we only support power-of-two for now, we should only have an llvm_unreachable if we prevent parsing any of the other widths (and give an appropriate diagnostic saying those widths are not yet supported).

Now that we check VecSize != S.getLangOpts().ArmSveVectorBits above I think this is ok as this shouldn't be reachable with -msve-vector-bits=<bits> validating the vector size.

clang/test/Sema/attr-arm-sve-vector-bits.c

99

Is this diagnostic produced because of any code-changes in this patch?

It isn't actually, I guess this could have gone in the first patch. Happy to move it if you think it's necessary.

155

nit: Is it necessary to test this for all the types?

I've reduced the number of types tested here.

[c-rhodes]

clang/include/clang/Basic/Attr.td

1577

I was thinking specifically of creating a new Type subclass and supporting it rather than adding 5 new attributes that only vary by a bit-width (which means there's likely to be a 6th someday).

It would be nice if the Attr was accessible from the AttributedType, similar to how it is for Decls, so something like:

if (const auto *AT = T->getAs<AttributedType>())
  if (ArmSveVectorBitsAttr *Attr = AT->getAttr<ArmSveVectorBits>())
    unsigned Width = Attr->getNumBits();

Although I'm not sure if that makes sense or how easy it is. I do agree adding 5 new attributes isn't ideal but for an initial implementation it's nice and simple. Would you be ok with us addressing this in a later patch?

[aaron.ballman]

clang/include/clang/AST/Type.h

1928

... this is a vector-length-sized type...

clang/include/clang/Basic/Attr.td

1577

It would be nice if the Attr was accessible from the AttributedType, similar to how it is for Decls, so something like:

You can do that through an AttributedTypeLoc object, which I think should be available from the situations you need to check this through a TypeSourceInfo * for the type. Then you can use AttributedTypeLoc::getAttr() to get the semantic attribute.

Would you be ok with us addressing this in a later patch?

No and yes. It's a novel design to have a user-facing attribute that is never hooked up in the AST but is instead used to decide which spellingless attribute to use instead, so I'd strongly prefer to find a solution that doesn't use this approach. I also think we'll wind up with cleaner code from this. That said, if it turns out to be awkward to do because there's too much code required to support it, then I can likely hold my nose.

[c-rhodes]

clang/include/clang/Basic/Attr.td

1577

You can do that through an AttributedTypeLoc object, which I think should be available from the situations you need to check this through a TypeSourceInfo * for the type. Then you can use AttributedTypeLoc::getAttr() to get the semantic attribute.

I've tried your suggestion with the following (in getSveVectorWidth):

TypeSourceInfo *TInfo = getTrivialTypeSourceInfo(QualType(T, 0));
TypeLoc TL = TInfo->getTypeLoc();
if (AttributedTypeLoc Attr = TL.getAs<AttributedTypeLoc>())
  if (const auto *AT = Attr.getAttrAs<ArmSveVectorBitsAttr>())
    llvm::outs() << AT->getNumBits() << "\n";

but can't seem to get it to work as there's no Attr attached to the AttributedTypeLoc. In this function in ASTContext all I have is a Type, I'm not sure if I'm missing something obvious.

I also tried it in HandleArmSveVectorBitsTypeAttr after creating the AttributedType to see how it would work and the following does allow me to query to vector size with getNumBits:

auto *A =
    ::new (Ctx) ArmSveVectorBitsAttr(Ctx, Attr, static_cast<unsigned>(VecSize));
A->setUsedAsTypeAttr();

CurType = State.getAttributedType(A, CurType, CurType);
TypeSourceInfo *TInfo = Ctx.CreateTypeSourceInfo(CurType);
TypeLoc TL = TInfo->getTypeLoc();
if (AttributedTypeLoc ATL = TL.getAs<AttributedTypeLoc>()) {
  ATL.setAttr(A);
  if (const auto *AT = ATL.getAttrAs<ArmSveVectorBitsAttr>())
    llvm::outs() << AT->getNumBits() << "\n";
}

Although I had to explicitly call ATL.setAttr(A);. It seems like the TypeSourceInfo is missing something, for reference the QualType I'm passing looks:

AttributedType 0x1946910 'svint8_t __attribute__((arm_sve_vector_bits))' sugar
|-TypedefType 0x19468a0 'svint8_t' sugar
| |-Typedef 0x19235c8 'svint8_t'
| `-TypedefType 0x1923590 '__SVInt8_t' sugar
|   |-Typedef 0x1921598 '__SVInt8_t'
|   `-BuiltinType 0x1881460 '__SVInt8_t'
`-TypedefType 0x19468a0 'svint8_t' sugar
  |-Typedef 0x19235c8 'svint8_t'
  `-TypedefType 0x1923590 '__SVInt8_t' sugar
    |-Typedef 0x1921598 '__SVInt8_t'
    `-BuiltinType 0x1881460 '__SVInt8_t'

I think I'll see if it's any easier to create a new Type.

[aaron.ballman]

clang/include/clang/Basic/Attr.td

1577

but can't seem to get it to work as there's no Attr attached to the AttributedTypeLoc.

That's surprising to me and smells like a bug. IIRC, the attribute is set in the AttributedTypeLoc object within the TypeSpecLocFiller builder in SemaType.cpp. Perhaps you could see whether that's being called properly before the call to ASTContext::getTypeInfoImpl()?

I think I'll see if it's any easier to create a new Type.

That's a reasonable fallback solution, but I'd like to understand why the existing machinery isn't workable and see if we can use that instead.

[c-rhodes]

clang/include/clang/Basic/Attr.td

1577

That's surprising to me and smells like a bug. IIRC, the attribute is set in the AttributedTypeLoc object within the TypeSpecLocFiller builder in SemaType.cpp. Perhaps you could see whether that's being called properly before the call to ASTContext::getTypeInfoImpl()?

Thanks for the pointers, I verified the Attr is being set for the AttributedTypeLoc in VisitAttributedTypeLoc (via fillAttributedTypeLoc) and I think this is attached to the TypeSourceInfo in GetTypeSourceInfoForDeclarator that is ultimately used to create a TypedefDecl in ActOnTypedefDeclarator. I can't see how it's possible to get an AttributedTypeLoc in ASTContext from the AttributedType alone. The TypeSpecLocFiller builder in SemaType.cpp is filling the TypeSourceInfo in for the decl and the only option I have in ASTContext is to create a new TypeSourceInfo.

That's a reasonable fallback solution, but I'd like to understand why the existing machinery isn't workable and see if we can use that instead.

Another alternative solution could be to get the vector size from the language options and have a single ArmSveVectorBits attribute. The only place we need to really query this is in ASTContext where we have access to the lang options. It would be nice to have this information in the TypePrinter as well but I think that's easily doable through the PrintingPolicy, although I'm not sure if that's really necessary. Would that be an acceptable approach?

[c-rhodes]

Changes:

• Remove internal type attributes (defined for each vector-size).
• Get the vector size from the arm_sve_vector_bits attribute via the AttributedTypeLoc associated with the typedef decl.
• Change NumBits argument for ArmSveVectorBits type attribute from int to unsigned.
• Only allow ArmSveVectorBits type attribute to be applied to typedefs (and added test).
• Set let PragmaAttributeSupport = 0; after specifying Subjects to fixed clang/test/Misc/pragma-attribute-supported-attributes-list.test.
• vector-length sized -> vector-length-sized.

[c-rhodes]

clang/include/clang/Basic/Attr.td

1577

I can't see how it's possible to get an AttributedTypeLoc in ASTContext from the AttributedType alone. The TypeSpecLocFiller builder in SemaType.cpp is filling the TypeSourceInfo in for the decl and the only option I have in ASTContext is to create a new TypeSourceInfo

@sdesmalen suggested calling getBitwidthForAttributedSveType for Type::Typedef (rather than AttributedType) in getTypeInfoImpl which works! From there the TypeSourceInfo can be pulled from the TypedefDecl I mentioned.

[aaron.ballman]

I like the way the code is shaping up with the slightly altered design, nice!

clang/lib/AST/ASTContext.cpp

1872

Should declare the method as static.

1887

Should this be dividing by the number of bits in a char for the target as opposed to hard-coding to 8?

[c-rhodes]

clang/lib/AST/ASTContext.cpp

1887

Should this be dividing by the number of bits in a char for the target as opposed to hard-coding to 8?

Predicate registers in SVE hold one bit per byte of a vector register so each predicate is 1/8th the size of a vector which are defined in bits, it has to be 8 and I know getCharWidth returns 8 for the target this is implemented for but I dont know what it would mean for any other target or if we care about that?

[c-rhodes]

• Make helpers static in ASTContext.
• Use getCharWidth.
• s/vector-length-sized/vector-length-specific.

[aaron.ballman]

The attribute bits LGTM, thanks!

clang/lib/AST/ASTContext.cpp

1887

Ah, so this is a case where we expect that value to always be 8 where this feature is supported anyway -- good to know. I still think the current code is a cleaner approach to hard-coding 8 bits, so thank you for making the change even though it doesn't enable much.

[c-rhodes]

In D83551#2164984, @aaron.ballman wrote:

The attribute bits LGTM, thanks!

Thanks for reviewing!

clang/include/clang/AST/ASTContext.h

if (Ty->isIncompleteType() || Ty->isDependentType())
       return None;
     return getTypeSizeInChars(Ty);
   }
 
   Optional<CharUnits> getTypeSizeInCharsIfKnown(const Type *Ty) const {
     return getTypeSizeInCharsIfKnown(QualType(Ty, 0));
   }
 
+  /// Returns the bitwidth of \p T, an SVE type attributed with
+  /// 'arm_sve_vector_bits(N)'. Should only be called if T->isVLST().
+  unsigned getBitwidthForAttributedSveType(const Type *T) const;
+
   /// Return the ABI-specified alignment of a (complete) type \p T, in
   /// bits.
   unsigned getTypeAlign(QualType T) const { return getTypeInfo(T).Align; }
   unsigned getTypeAlign(const Type *T) const { return getTypeInfo(T).Align; }
 
   /// Return the ABI-specified natural alignment of a (complete) type \p T,
   /// before alignment adjustments, in bits.
   ///

clang/include/clang/AST/Type.h

public:
   /// every type is one or the other.  Standard types are all sized;
   /// sizeless types are purely an extension.
   ///
   /// Sizeless types contain data with no specified size, alignment,
   /// or layout.
   bool isSizelessType() const;
   bool isSizelessBuiltinType() const;
 
+  /// Determines if this is vector-length sized typed (VLST), i.e. a
+  /// sizeless type with the 'arm_sve_vector_bits(N)' attribute applied.
+  bool isVLST() const;
   /// Determines if this is a sizeless type supported by the
   /// 'arm_sve_vector_bits' type attribute, which can be applied to a single
   /// SVE vector or predicate, excluding tuple types such as svint32x4_t.
   bool isVLSTBuiltinType() const;
 
   /// Types are partitioned into 3 broad categories (C99 6.2.5p1):
   /// object types, function types, and incomplete types.
 

clang/include/clang/Basic/Attr.td

def NeonVectorType : TypeAttr {
   // Represented as VectorType instead.
   let ASTNode = 0;
 }
 
 def ArmSveVectorBits : TypeAttr {
   let Spellings = [GNU<"arm_sve_vector_bits">];
   let Args = [IntArgument<"NumBits">];
   let Documentation = [ArmSveVectorBitsDocs];
+  // Represented internally as ArmSveVectorBits<n> type attributes.
+  let ASTNode = 0;
+}
+
+// ArmSveVectorBits type attributes for each supported vector-length. These are
+// intended for internal use only and are therefore undocumented. Users should
+// use the user-facing ArmSveVectorBits attribute that is lowered to one of
+// these attributes.
+def ArmSveVectorBits128 : TypeAttr {
+  let Spellings = [];
+  let Documentation = [Undocumented];
+  let SemaHandler = 0;
+}
+
+def ArmSveVectorBits256 : TypeAttr {
+  let Spellings = [];
+  let Documentation = [Undocumented];
+  let SemaHandler = 0;
+}
+
+def ArmSveVectorBits512 : TypeAttr {
+  let Spellings = [];
+  let Documentation = [Undocumented];
+  let SemaHandler = 0;
+}
+
+def ArmSveVectorBits1024 : TypeAttr {
+  let Spellings = [];
+  let Documentation = [Undocumented];
+  let SemaHandler = 0;
+}
+
+def ArmSveVectorBits2048 : TypeAttr {
+  let Spellings = [];
+  let Documentation = [Undocumented];
+  let SemaHandler = 0;
 }
 
 def ArmMveStrictPolymorphism : TypeAttr, TargetSpecificAttr<TargetARM> {
   let Spellings = [Clang<"__clang_arm_mve_strict_polymorphism">];
   let Documentation = [ArmMveStrictPolymorphismDocs];
 }
 
 def NoUniqueAddress : InheritableAttr, TargetSpecificAttr<TargetItaniumCXXABI> {
   let Spellings = [CXX11<"", "no_unique_address", 201803>];
   let Subjects = SubjectList<[NonBitField], ErrorDiag>;
   let Documentation = [NoUniqueAddressDocs];

clang/include/clang/Sema/Sema.h

bool RequireCompleteType(SourceLocation Loc, QualType T, unsigned DiagID,
     BoundTypeDiagnoser<Ts...> Diagnoser(DiagID, Args...);
     return RequireCompleteType(Loc, T, Diagnoser);
   }
 
   template <typename... Ts>
   bool RequireCompleteSizedType(SourceLocation Loc, QualType T, unsigned DiagID,
                                 const Ts &... Args) {
     SizelessTypeDiagnoser<Ts...> Diagnoser(DiagID, Args...);
-    return RequireCompleteType(Loc, T, CompleteTypeKind::Normal, Diagnoser);
+    CompleteTypeKind Kind = CompleteTypeKind::Normal;
+    if (T->isVLST())
+      Kind = CompleteTypeKind::AcceptSizeless;
+    return RequireCompleteType(Loc, T, Kind, Diagnoser);
   }
 
   void completeExprArrayBound(Expr *E);
   bool RequireCompleteExprType(Expr *E, CompleteTypeKind Kind,
                                TypeDiagnoser &Diagnoser);
   bool RequireCompleteExprType(Expr *E, unsigned DiagID);
 
   template <typename... Ts>
   bool RequireCompleteExprType(Expr *E, unsigned DiagID, const Ts &...Args) {
     BoundTypeDiagnoser<Ts...> Diagnoser(DiagID, Args...);
     return RequireCompleteExprType(E, CompleteTypeKind::Default, Diagnoser);
   }
 
   template <typename... Ts>
   bool RequireCompleteSizedExprType(Expr *E, unsigned DiagID,
                                     const Ts &... Args) {
     SizelessTypeDiagnoser<Ts...> Diagnoser(DiagID, Args...);
-    return RequireCompleteExprType(E, CompleteTypeKind::Normal, Diagnoser);
+    CompleteTypeKind Kind = CompleteTypeKind::Normal;
+    if (E->getType()->isVLST())
+      Kind = CompleteTypeKind::AcceptSizeless;
+    return RequireCompleteExprType(E, Kind, Diagnoser);
   }
 
   bool RequireLiteralType(SourceLocation Loc, QualType T,
                           TypeDiagnoser &Diagnoser);
   bool RequireLiteralType(SourceLocation Loc, QualType T, unsigned DiagID);
 
   template <typename... Ts>
   bool RequireLiteralType(SourceLocation Loc, QualType T, unsigned DiagID,

clang/lib/AST/ASTContext.cpp

if (I != MemoizedTypeInfo.end())
     return I->second;
 
   // This call can invalidate MemoizedTypeInfo[T], so we need a second lookup.
   TypeInfo TI = getTypeInfoImpl(T);
   MemoizedTypeInfo[T] = TI;
   return TI;
 }
 
+unsigned getSveVectorWidth(const Type *T) {
+  if (T->hasAttr(attr::ArmSveVectorBits128))
+    return 128;
+  else if (T->hasAttr(attr::ArmSveVectorBits256))
+    return 256;
+  else if (T->hasAttr(attr::ArmSveVectorBits512))
+    return 512;
+  else if (T->hasAttr(attr::ArmSveVectorBits1024))
+    return 1024;
+  else if (T->hasAttr(attr::ArmSveVectorBits2048))
+    return 2048;
+
+  llvm_unreachable("missing 'arm_sve_vector_bits' attribute!");
+}
+
+unsigned getSvePredWidth(const Type *T) {
+  // Bit per byte
+  return getSveVectorWidth(T) / 8;
+}
+
+unsigned ASTContext::getBitwidthForAttributedSveType(const Type *T) const {
+  assert(T->isVLST() &&
+         "getBitwidthForAttributedSveType called for non-attributed type!");
+
+  switch (T->castAs<BuiltinType>()->getKind()) {
+  default:
+    llvm_unreachable("unknown builtin type!");
+  case BuiltinType::SveInt8:
+  case BuiltinType::SveInt16:
+  case BuiltinType::SveInt32:
+  case BuiltinType::SveInt64:
+  case BuiltinType::SveUint8:
+  case BuiltinType::SveUint16:
+  case BuiltinType::SveUint32:
+  case BuiltinType::SveUint64:
+  case BuiltinType::SveFloat16:
+  case BuiltinType::SveFloat32:
+  case BuiltinType::SveFloat64:
+  case BuiltinType::SveBFloat16:
+    return getSveVectorWidth(T);
+  case BuiltinType::SveBool:
+    return getSvePredWidth(T);
+  }
+}
+
 /// getTypeInfoImpl - Return the size of the specified type, in bits.  This
 /// method does not work on incomplete types.
 ///
 /// FIXME: Pointers into different addr spaces could have different sizes and
 /// alignment requirements: getPointerInfo should take an AddrSpace, this
 /// should take a QualType, &c.
 TypeInfo ASTContext::getTypeInfoImpl(const Type *T) const {
   uint64_t Width = 0;
case Type::Typedef: {
     }
     Width = Info.Width;
     break;
   }
 
   case Type::Elaborated:
     return getTypeInfo(cast<ElaboratedType>(T)->getNamedType().getTypePtr());
 
-  case Type::Attributed:
-    return getTypeInfo(
-                  cast<AttributedType>(T)->getEquivalentType().getTypePtr());
+  case Type::Attributed: {
+    TypeInfo Info =
+        getTypeInfo(cast<AttributedType>(T)->getEquivalentType().getTypePtr());
+    if (!T->isVLST())
+      return Info;
+    Width = getBitwidthForAttributedSveType(T);
+    Align = Info.Align;
+    break;
+  }
 
   case Type::Atomic: {
     // Start with the base type information.
     TypeInfo Info = getTypeInfo(cast<AtomicType>(T)->getValueType());
     Width = Info.Width;
     Align = Info.Align;
 
     if (!Width) {

clang/lib/AST/Type.cpp

case BuiltinType::SveBool:
       return true;
     default:
       return false;
     }
   }
   return false;
 }
 
+bool Type::isVLST() const {
+  if (!isVLSTBuiltinType())
+    return false;
+
+  if (hasAttr(attr::ArmSveVectorBits128) ||
+      hasAttr(attr::ArmSveVectorBits256) ||
+      hasAttr(attr::ArmSveVectorBits512) ||
+      hasAttr(attr::ArmSveVectorBits1024) ||
+      hasAttr(attr::ArmSveVectorBits2048))
+    return true;
+
+  return false;
+}
+
 bool QualType::isPODType(const ASTContext &Context) const {
   // C++11 has a more relaxed definition of POD.
   if (Context.getLangOpts().CPlusPlus11)
     return isCXX11PODType(Context);
 
   return isCXX98PODType(Context);
 }
 

clang/lib/AST/TypePrinter.cpp

case attr::NoDeref:
     OS << "noderef";
     break;
   case attr::AcquireHandle:
     OS << "acquire_handle";
     break;
   case attr::ArmMveStrictPolymorphism:
     OS << "__clang_arm_mve_strict_polymorphism";
     break;
-  case attr::ArmSveVectorBits:
-    OS << "arm_sve_vector_bits";
+  case attr::ArmSveVectorBits128:
+    OS << "arm_sve_vector_bits(128)";
+    break;
+  case attr::ArmSveVectorBits256:
+    OS << "arm_sve_vector_bits(256)";
+    break;
+  case attr::ArmSveVectorBits512:
+    OS << "arm_sve_vector_bits(512)";
+    break;
+  case attr::ArmSveVectorBits1024:
+    OS << "arm_sve_vector_bits(1024)";
+    break;
+  case attr::ArmSveVectorBits2048:
+    OS << "arm_sve_vector_bits(2048)";
     break;
   }
   OS << "))";
 }
 
 void TypePrinter::printObjCInterfaceBefore(const ObjCInterfaceType *T,
                                            raw_ostream &OS) {
   OS << T->getDecl()->getName();

clang/lib/Sema/SemaDecl.cpp

void Sema::CheckVariableDeclarationType(VarDecl *NewVD) {
   }
 
   if (!NewVD->hasLocalStorage() && NewVD->hasAttr<BlocksAttr>()) {
     Diag(NewVD->getLocation(), diag::err_block_on_nonlocal);
     NewVD->setInvalidDecl();
     return;
   }
 
-  if (!NewVD->hasLocalStorage() && T->isSizelessType()) {
+  if (!NewVD->hasLocalStorage() && T->isSizelessType() && !T->isVLST()) {
     Diag(NewVD->getLocation(), diag::err_sizeless_nonlocal) << T;
     NewVD->setInvalidDecl();
     return;
   }
 
   if (isVM && NewVD->hasAttr<BlocksAttr>()) {
     Diag(NewVD->getLocation(), diag::err_block_on_vm);
     NewVD->setInvalidDecl();

clang/lib/Sema/SemaType.cpp

QualType Sema::BuildArrayType(QualType T, ArrayType::ArraySizeModifier ASM,
   } else {
     // C99 6.7.5.2p1: If the element type is an incomplete or function type,
     // reject it (e.g. void ary[7], struct foo ary[7], void ary[7]())
     if (RequireCompleteSizedType(Loc, T,
                                  diag::err_array_incomplete_or_sizeless_type))
       return QualType();
   }
 
-  if (T->isSizelessType()) {
+  if (T->isSizelessType() && !T->isVLST()) {
     Diag(Loc, diag::err_array_incomplete_or_sizeless_type) << 1 << T;
     return QualType();
   }
 
   if (T->isFunctionType()) {
     Diag(Loc, diag::err_illegal_decl_array_of_functions)
       << getPrintableNameForEntity(Entity) << T;
     return QualType();
static void HandleNeonVectorTypeAttr(QualType &CurType, const ParsedAttr &Attr,
   }
 
   CurType = S.Context.getVectorType(CurType, numElts, VecKind);
 }
 
 /// HandleArmSveVectorBitsTypeAttr - The "arm_sve_vector_bits" attribute is
 /// used to create fixed-length versions of sizeless SVE types defined by
 /// the ACLE, such as svint32_t and svbool_t.
-static void HandleArmSveVectorBitsTypeAttr(QualType &CurType,
-                                           const ParsedAttr &Attr, Sema &S) {
+static void HandleArmSveVectorBitsTypeAttr(TypeProcessingState &State,
+                                           QualType &CurType,
+                                           ParsedAttr &Attr) {
+  Sema &S = State.getSema();
+  ASTContext &Ctx = S.Context;
+
   // Target must have SVE.
-  if (!S.Context.getTargetInfo().hasFeature("sve")) {
+  if (!Ctx.getTargetInfo().hasFeature("sve")) {
     S.Diag(Attr.getLoc(), diag::err_attribute_unsupported) << Attr;
     Attr.setInvalid();
     return;
   }
 
   // Attribute is unsupported if '-msve-vector-bits=<bits>' isn't specified.
   if (!S.getLangOpts().ArmSveVectorBits) {
     S.Diag(Attr.getLoc(), diag::err_attribute_arm_feature_sve_bits_unsupported)
static void HandleArmSveVectorBitsTypeAttr(TypeProcessingState &State,
 
   // Attribute can only be attached to a single SVE vector or predicate type.
   if (!CurType->isVLSTBuiltinType()) {
     S.Diag(Attr.getLoc(), diag::err_attribute_invalid_sve_type)
         << Attr << CurType;
     Attr.setInvalid();
     return;
   }
+
+  clang::Attr *A;
+  switch (SveVectorSizeInBits.getZExtValue()) {
+  default:
+    llvm_unreachable("unsupported vector size!");
+  case 128:
+    A = createSimpleAttr<ArmSveVectorBits128Attr>(Ctx, Attr);
+    break;
+  case 256:
+    A = createSimpleAttr<ArmSveVectorBits256Attr>(Ctx, Attr);
+    break;
+  case 512:
+    A = createSimpleAttr<ArmSveVectorBits512Attr>(Ctx, Attr);
+    break;
+  case 1024:
+    A = createSimpleAttr<ArmSveVectorBits1024Attr>(Ctx, Attr);
+    break;
+  case 2048:
+    A = createSimpleAttr<ArmSveVectorBits2048Attr>(Ctx, Attr);
+    break;
+  }
+
+  CurType = State.getAttributedType(A, CurType, CurType);
 }
 
 static void HandleArmMveStrictPolymorphismAttr(TypeProcessingState &State,
                                                QualType &CurType,
                                                ParsedAttr &Attr) {
   const VectorType *VT = dyn_cast<VectorType>(CurType);
   if (!VT || VT->getVectorKind() != VectorType::NeonVector) {
     State.getSema().Diag(Attr.getLoc(),
case ParsedAttr::AT_NeonVectorType:
       attr.setUsedAsTypeAttr();
       break;
     case ParsedAttr::AT_NeonPolyVectorType:
       HandleNeonVectorTypeAttr(type, attr, state.getSema(),
                                VectorType::NeonPolyVector);
       attr.setUsedAsTypeAttr();
       break;
     case ParsedAttr::AT_ArmSveVectorBits:
-      HandleArmSveVectorBitsTypeAttr(type, attr, state.getSema());
+      HandleArmSveVectorBitsTypeAttr(state, type, attr);
       attr.setUsedAsTypeAttr();
       break;
     case ParsedAttr::AT_ArmMveStrictPolymorphism: {
       HandleArmMveStrictPolymorphismAttr(state, type, attr);
       attr.setUsedAsTypeAttr();
       break;
     }
     case ParsedAttr::AT_OpenCLAccess:

clang/test/Sema/attr-arm-sve-vector-bits.c

 typedef __clang_svfloat32x3_t svfloat32x3_t;
 
 // Attribute must be attached to a single SVE vector or predicate type.
 typedef void *badtype1 __attribute__((arm_sve_vector_bits(N)));         // expected-error {{'arm_sve_vector_bits' attribute applied to non-SVE type 'void *'}}
 typedef int badtype2 __attribute__((arm_sve_vector_bits(N)));           // expected-error {{'arm_sve_vector_bits' attribute applied to non-SVE type 'int'}}
 typedef float badtype3 __attribute__((arm_sve_vector_bits(N)));         // expected-error {{'arm_sve_vector_bits' attribute applied to non-SVE type 'float'}}
 typedef svint8x2_t badtype4 __attribute__((arm_sve_vector_bits(N)));    // expected-error {{'arm_sve_vector_bits' attribute applied to non-SVE type 'svint8x2_t' (aka '__clang_svint8x2_t')}}
 typedef svfloat32x3_t badtype5 __attribute__((arm_sve_vector_bits(N))); // expected-error {{'arm_sve_vector_bits' attribute applied to non-SVE type 'svfloat32x3_t' (aka '__clang_svfloat32x3_t')}}
+
+// Test that we can define non-local fixed-length SVE types (unsupported for
+// sizeless types).
+fixed_int8_t global_int8;
+fixed_bfloat16_t global_bfloat16;
+fixed_bool_t global_bool;
+
+extern fixed_int8_t extern_int8;
+extern fixed_bfloat16_t extern_bfloat16;
+extern fixed_bool_t extern_bool;
+
+static fixed_int8_t static_int8;
+static fixed_bfloat16_t static_bfloat16;
+static fixed_bool_t static_bool;
+
+fixed_int8_t *global_int8_ptr;
+extern fixed_int8_t *extern_int8_ptr;
+static fixed_int8_t *static_int8_ptr;
+__thread fixed_int8_t thread_int8;
+
+typedef fixed_int8_t int8_typedef;
+typedef fixed_int8_t *int8_ptr_typedef;
+
+// Test sized expressions
+int sizeof_int8 = sizeof(global_int8);
+int sizeof_int8_var = sizeof(*global_int8_ptr);
+int sizeof_int8_var_ptr = sizeof(global_int8_ptr);
+
+extern fixed_int8_t *extern_int8_ptr;
+
+int alignof_int8 = __alignof__(extern_int8);
+int alignof_int8_var = __alignof__(*extern_int8_ptr);
+int alignof_int8_var_ptr = __alignof__(extern_int8_ptr);
+
+void f(int c) {
+  fixed_int8_t fs8;
+  svint8_t ss8;
+
+  void *sel __attribute__((unused));
+  sel = c ? ss8 : fs8; // expected-error {{incompatible operand types ('svint8_t' (aka '__SVInt8_t') and 'fixed_int8_t' (aka '__SVInt8_t'))}}
+  sel = c ? fs8 : ss8; // expected-error {{incompatible operand types ('fixed_int8_t' (aka '__SVInt8_t') and 'svint8_t' (aka '__SVInt8_t'))}}
+}
+
+// --------------------------------------------------------------------------//
+// Sizeof
+
+#define VECTOR_SIZE ((N / 8))
+#define PRED_SIZE ((N / 64))
+
+_Static_assert(sizeof(fixed_int8_t) == VECTOR_SIZE, "");
+
+_Static_assert(sizeof(fixed_int16_t) == VECTOR_SIZE, "");
+_Static_assert(sizeof(fixed_int32_t) == VECTOR_SIZE, "");
+_Static_assert(sizeof(fixed_int64_t) == VECTOR_SIZE, "");
+
+_Static_assert(sizeof(fixed_uint8_t) == VECTOR_SIZE, "");
+_Static_assert(sizeof(fixed_uint16_t) == VECTOR_SIZE, "");
+_Static_assert(sizeof(fixed_uint32_t) == VECTOR_SIZE, "");
+_Static_assert(sizeof(fixed_uint64_t) == VECTOR_SIZE, "");
+
+_Static_assert(sizeof(fixed_float16_t) == VECTOR_SIZE, "");
+_Static_assert(sizeof(fixed_float32_t) == VECTOR_SIZE, "");
+_Static_assert(sizeof(fixed_float64_t) == VECTOR_SIZE, "");
+
+_Static_assert(sizeof(fixed_bfloat16_t) == VECTOR_SIZE, "");
+
+_Static_assert(sizeof(fixed_bool_t) == PRED_SIZE, "");
+
+// --------------------------------------------------------------------------//
+// Alignof
+
+#define VECTOR_ALIGN 16
+#define PRED_ALIGN 2
+
+_Static_assert(__alignof__(fixed_int8_t) == VECTOR_ALIGN, "");
+_Static_assert(__alignof__(fixed_int16_t) == VECTOR_ALIGN, "");
+_Static_assert(__alignof__(fixed_int32_t) == VECTOR_ALIGN, "");
+_Static_assert(__alignof__(fixed_int64_t) == VECTOR_ALIGN, "");
+
+_Static_assert(__alignof__(fixed_uint8_t) == VECTOR_ALIGN, "");
+_Static_assert(__alignof__(fixed_uint16_t) == VECTOR_ALIGN, "");
+_Static_assert(__alignof__(fixed_uint32_t) == VECTOR_ALIGN, "");
+_Static_assert(__alignof__(fixed_uint64_t) == VECTOR_ALIGN, "");
+
+_Static_assert(__alignof__(fixed_float16_t) == VECTOR_ALIGN, "");
+_Static_assert(__alignof__(fixed_float32_t) == VECTOR_ALIGN, "");
+_Static_assert(__alignof__(fixed_float64_t) == VECTOR_ALIGN, "");
+
+_Static_assert(__alignof__(fixed_bfloat16_t) == VECTOR_ALIGN, "");
+
+_Static_assert(__alignof__(fixed_bool_t) == PRED_ALIGN, "");
+
+// --------------------------------------------------------------------------//
+// Structs
+
+struct struct_int64 { fixed_int64_t x, y[5]; };
+struct struct_float64 { fixed_float64_t x, y[5]; };
+struct struct_bfloat16 { fixed_bfloat16_t x, y[5]; };
+struct struct_bool { fixed_bool_t x, y[5]; };
+
+// --------------------------------------------------------------------------//
+// Unions
+union union_int64 { fixed_int64_t x, y[5]; };
+union union_float64 { fixed_float64_t x, y[5]; };
+union union_bfloat16 { fixed_bfloat16_t x, y[5]; };
+union union_bool { fixed_bool_t x, y[5]; };
+
+// --------------------------------------------------------------------------//
+// Implicit casts
+
+#define TEST_CAST(TYPE)                                          \
+  sv##TYPE##_t to_sv##TYPE##_t(fixed_##TYPE##_t x) { return x; } \
+  fixed_##TYPE##_t from_sv##TYPE##_t(sv##TYPE##_t x) { return x; }
+
+TEST_CAST(int8)
+TEST_CAST(int16)
+TEST_CAST(int32)
+TEST_CAST(int64)
+TEST_CAST(uint8)
+TEST_CAST(uint16)
+TEST_CAST(uint32)
+TEST_CAST(uint64)
+TEST_CAST(float16)
+TEST_CAST(float32)
+TEST_CAST(float64)
+TEST_CAST(bfloat16)
+TEST_CAST(bool)
+
+// Test the implicit conversion only applies to valid types
+fixed_int8_t to_fixed_int8_t__from_svuint8_t(svuint8_t x) { return x; } // expected-error {{returning 'svuint8_t' (aka '__SVUint8_t') from a function with incompatible result type 'fixed_int8_t' (aka '__SVInt8_t')}}
+fixed_bool_t to_fixed_bool_t__from_svint32_t(svint32_t x) { return x; } // expected-error {{returning 'svint32_t' (aka '__SVInt32_t') from a function with incompatible result type 'fixed_bool_t' (aka '__SVBool_t')}}
+
+// Test the implicit conversion only applies to fixed-length types
+typedef signed int vSInt32 __attribute__((__vector_size__(16)));
+svint32_t to_svint32_t_from_gnut(vSInt32 x) { return x; } // expected-error {{returning 'vSInt32' (vector of 4 'int' values) from a function with incompatible result type 'svint32_t' (aka '__SVInt32_t')}}
+
+vSInt32 to_gnut_from_svint32_t(svint32_t x) { return x; } // expected-error {{returning 'svint32_t' (aka '__SVInt32_t') from a function with incompatible result type 'vSInt32' (vector of 4 'int' values)}}
+
+// --------------------------------------------------------------------------//
+// Test the scalable and fixed-length types can be used interchangeably
+
+svint32_t __attribute__((overloadable)) svfunc(svint32_t op1, svint32_t op2);
+svfloat64_t __attribute__((overloadable)) svfunc(svfloat64_t op1, svfloat64_t op2);
+svbool_t __attribute__((overloadable)) svfunc(svbool_t op1, svbool_t op2);
+
+#define TEST_CALL(TYPE)                                              \
+  fixed_##TYPE##_t                                                   \
+      call_##TYPE##_ff(fixed_##TYPE##_t op1, fixed_##TYPE##_t op2) { \
+    return svfunc(op1, op2);                                         \
+  }                                                                  \
+  fixed_##TYPE##_t                                                   \
+      call_##TYPE##_fs(fixed_##TYPE##_t op1, sv##TYPE##_t op2) {     \
+    return svfunc(op1, op2);                                         \
+  }                                                                  \
+  fixed_##TYPE##_t                                                   \
+      call_##TYPE##_sf(sv##TYPE##_t op1, fixed_##TYPE##_t op2) {     \
+    return svfunc(op1, op2);                                         \
+  }
+
+TEST_CALL(int32)
+TEST_CALL(float64)
+TEST_CALL(bool)