[PATCH 1/3] [RFC only] Hack to add some sizeless built-in types

[rsandifo-arm]

Summary

[ Not intended for commit. I'm just posting it to back up an

RFC on cfe-dev. ]

This patch is a hack to add two new "sizeless builtin" types SVInt8_t
and SVInt16_t. The real SVE implementation looks nothing like this;
the patch is just the most direct way of adding two distinct sizeless
types to the type system, so that a follow-on patch can add and test
support for sizeless types in a meaningful way.

[rsandifo-arm]

Abandoning in favour of:

https://reviews.llvm.org/D62960
https://reviews.llvm.org/D62961
https://reviews.llvm.org/D62962

include/clang/AST/ASTContext.h

public:
   CanQualType ObjCBuiltinIdTy, ObjCBuiltinClassTy, ObjCBuiltinSelTy;
   CanQualType ObjCBuiltinBoolTy;
 #define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
   CanQualType SingletonId;
 #include "clang/Basic/OpenCLImageTypes.def"
   CanQualType OCLSamplerTy, OCLEventTy, OCLClkEventTy;
   CanQualType OCLQueueTy, OCLReserveIDTy;
   CanQualType OMPArraySectionTy;
+  // NOT intended for commit, just a crutch to provide some sizeless types.
+  // The real SVE support will include a way of defining target-specific
+  // types like these.
+  CanQualType AArch64SVEInt8Ty, AArch64SVEInt16Ty;
 
   // Types for deductions in C++0x [stmt.ranged]'s desugaring. Built on demand.
   mutable QualType AutoDeductTy;     // Deduction against 'auto'.
   mutable QualType AutoRRefDeductTy; // Deduction against 'auto &&'.
 
   // Decl used to help define __builtin_va_list for some targets.
   // The decl is built when constructing 'BuiltinVaListDecl'.
   mutable Decl *VaListTagDecl;

include/clang/AST/BuiltinTypes.def

 BUILTIN_TYPE(OCLClkEvent, OCLClkEventTy)
 
 // OpenCL queue_t.
 BUILTIN_TYPE(OCLQueue, OCLQueueTy)
 
 // OpenCL reserve_id_t.
 BUILTIN_TYPE(OCLReserveID, OCLReserveIDTy)
 
+// NOT intended for commit, just a crutch to provide some sizeless types.
+// The real SVE support will include a way of defining target-specific
+// types like these.
+BUILTIN_TYPE(AArch64SVEInt8, AArch64SVEInt8Ty)
+BUILTIN_TYPE(AArch64SVEInt16, AArch64SVEInt16Ty)
+
 // This represents the type of an expression whose type is
 // totally unknown, e.g. 'T::foo'.  It is permitted for this to
 // appear in situations where the structure of the type is
 // theoretically deducible.
 BUILTIN_TYPE(Dependent, DependentTy)
 
 // The type of an unresolved overload set.  A placeholder type.
 // Expressions with this type have one of the following basic

include/clang/AST/CanonicalType.h

template<typename U> CanProxy<U> getAs() const {
     return this->Stored.template getAs<U>();
   }
 
   LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(Type::TypeClass, getTypeClass)
 
   // Type predicates
   LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(bool, isObjectType)
   LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(bool, isIncompleteType)
+  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(bool, isSizelessType)
+  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(bool, isSizelessBuiltinType)
   LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(bool, isIncompleteOrObjectType)
   LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(bool, isVariablyModifiedType)
   LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(bool, isIntegerType)
   LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(bool, isEnumeralType)
   LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(bool, isBooleanType)
   LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(bool, isCharType)
   LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(bool, isWideCharType)
   LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(bool, isIntegralType)

include/clang/AST/Type.h

bool isCanonicalUnqualified() const {
     return CanonicalType == QualType(this, 0);
   }
 
   /// Pull a single level of sugar off of this locally-unqualified type.
   /// Users should generally prefer SplitQualType::getSingleStepDesugaredType()
   /// or QualType::getSingleStepDesugaredType(const ASTContext&).
   QualType getLocallyUnqualifiedSingleStepDesugaredType() const;
 
+  /// As an extension, we classify types as one of "sized" or "sizeless";
+  /// 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.  They are always incomplete.
+  bool isSizelessType() const;
+  bool isSizelessBuiltinType() const;
+
   /// Types are partitioned into 3 broad categories (C99 6.2.5p1):
   /// object types, function types, and incomplete types.
 
   /// Return true if this is an incomplete type.
   /// A type that can describe objects, but which lacks information needed to
   /// determine its size (e.g. void, or a fwd declared struct). Clients of this
   /// routine will need to determine if the size is actually required.
   ///

include/clang/Serialization/ASTBitCodes.h

enum PredefinedTypeIDs {
 
       /// \brief The C++ 'char8_t' type.
       PREDEF_TYPE_CHAR8_ID = 45,
 
       /// \brief OpenCL image types with auto numeration
 #define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
       PREDEF_TYPE_##Id##_ID,
 #include "clang/Basic/OpenCLImageTypes.def"
+
+      // NOT intended for commit, just a crutch to provide some sizeless types.
+      // The real SVE support will include a way of defining target-specific
+      // types like these.
+      PREDEF_TYPE_AARCH64_SVE_INT8 = 98,
+      PREDEF_TYPE_AARCH64_SVE_INT16 = 99
     };
 
     /// \brief The number of predefined type IDs that are reserved for
     /// the PREDEF_TYPE_* constants.
     ///
     /// Type IDs for non-predefined types will start at
     /// NUM_PREDEF_TYPE_IDs.
     const unsigned NUM_PREDEF_TYPE_IDS = 100;

lib/AST/ASTContext.cpp

#include "clang/Basic/OpenCLImageTypes.def"
   // nullptr type (C++0x 2.14.7)
   InitBuiltinType(NullPtrTy,           BuiltinType::NullPtr);
 
   // half type (OpenCL 6.1.1.1) / ARM NEON __fp16
   InitBuiltinType(HalfTy, BuiltinType::Half);
 
   // Builtin type used to help define __builtin_va_list.
   VaListTagDecl = nullptr;
+
+  // NOT intended for commit, just a crutch to provide some sizeless types.
+  // The real SVE support will include a way of defining target-specific
+  // types like these.
+  InitBuiltinType(AArch64SVEInt8Ty, BuiltinType::AArch64SVEInt8);
+  InitBuiltinType(AArch64SVEInt16Ty, BuiltinType::AArch64SVEInt16);
 }
 
 DiagnosticsEngine &ASTContext::getDiagnostics() const {
   return SourceMgr.getDiagnostics();
 }
 
 AttrVec& ASTContext::getDeclAttrs(const Decl *D) {
   AttrVec *&Result = DeclAttrs[D];
#include "clang/Basic/OpenCLImageTypes.def"
     case BuiltinType::OCLQueue:
     case BuiltinType::OCLReserveID:
     case BuiltinType::OCLSampler:
     case BuiltinType::Dependent:
 #define BUILTIN_TYPE(KIND, ID)
 #define PLACEHOLDER_TYPE(KIND, ID) \
     case BuiltinType::KIND:
 #include "clang/AST/BuiltinTypes.def"
+    // NOT intended for commit, just a crutch to provide some sizeless types.
+    // The real SVE support will include a way of defining target-specific
+    // types like these.
+    case BuiltinType::AArch64SVEInt8:
+    case BuiltinType::AArch64SVEInt16:
       llvm_unreachable("invalid builtin type for @encode");
     }
     llvm_unreachable("invalid BuiltinType::Kind value");
 }
 
 static char ObjCEncodingForEnumType(const ASTContext *C, const EnumType *ET) {
   EnumDecl *Enum = ET->getDecl();
   

lib/AST/ExprConstant.cpp

#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
     case BuiltinType::Id:
 #include "clang/Basic/OpenCLImageTypes.def"
     case BuiltinType::OCLSampler:
     case BuiltinType::OCLEvent:
     case BuiltinType::OCLClkEvent:
     case BuiltinType::OCLQueue:
     case BuiltinType::OCLReserveID:
     case BuiltinType::Dependent:
+    // NOT intended for commit, just a crutch to provide some sizeless types.
+    // The real SVE support will include a way of defining target-specific
+    // types like these.
+    case BuiltinType::AArch64SVEInt8:
+    case BuiltinType::AArch64SVEInt16:
       llvm_unreachable("CallExpr::isBuiltinClassifyType(): unimplemented type");
     };
     break;
 
   case Type::Enum:
     return LangOpts.CPlusPlus ? enumeral_type_class : integer_type_class;
     break;
 

lib/AST/ItaniumMangle.cpp

case BuiltinType::OCLClkEvent:
     Out << "12ocl_clkevent";
     break;
   case BuiltinType::OCLQueue:
     Out << "9ocl_queue";
     break;
   case BuiltinType::OCLReserveID:
     Out << "13ocl_reserveid";
     break;
+  // NOT intended for commit, just a crutch to provide some sizeless types.
+  // The real SVE support will include a way of defining target-specific
+  // types like these.
+  case BuiltinType::AArch64SVEInt8:
+  case BuiltinType::AArch64SVEInt16:
+    llvm_unreachable("Mangling of SVE types not supported yet");
   }
 }
 
 StringRef CXXNameMangler::getCallingConvQualifierName(CallingConv CC) {
   switch (CC) {
   case CC_C:
     return "";
 

lib/AST/MicrosoftMangle.cpp

case BuiltinType::NullPtr:
     Out << "$$T";
     break;
 
   case BuiltinType::Char8:
   case BuiltinType::Float16:
     mangleArtificalTagType(TTK_Struct, "_Float16", {"__clang"});
     break;
 
+  // NOT intended for commit, just a crutch to provide some sizeless types.
+  // The real SVE support will include a way of defining target-specific
+  // types like these.
+  case BuiltinType::AArch64SVEInt8:
+  case BuiltinType::AArch64SVEInt16:
   case BuiltinType::Float128:
   case BuiltinType::Half: {
     DiagnosticsEngine &Diags = Context.getDiags();
     unsigned DiagID = Diags.getCustomDiagID(
         DiagnosticsEngine::Error, "cannot mangle this built-in %0 type yet");
     Diags.Report(Range.getBegin(), DiagID)
         << T->getName(Context.getASTContext().getPrintingPolicy()) << Range;
     break;

lib/AST/NSAPI.cpp

#include "clang/Basic/OpenCLImageTypes.def"
   case BuiltinType::Dependent:
   case BuiltinType::Overload:
   case BuiltinType::UnknownAny:
   case BuiltinType::ARCUnbridgedCast:
   case BuiltinType::Half:
   case BuiltinType::PseudoObject:
   case BuiltinType::BuiltinFn:
   case BuiltinType::OMPArraySection:
+  // NOT intended for commit, just a crutch to provide some sizeless types.
+  // The real SVE support will include a way of defining target-specific
+  // types like these.
+  case BuiltinType::AArch64SVEInt8:
+  case BuiltinType::AArch64SVEInt16:
     break;
   }
   
   return None;
 }
 
 /// \brief Returns true if \param T is a typedef of "BOOL" in objective-c.
 bool NSAPI::isObjCBOOLType(QualType T) const {

lib/AST/Type.cpp

ObjCInterfaceDecl *Interface
       = cast<ObjCInterfaceType>(CanonicalType)->getDecl();
     if (Def)
       *Def = Interface;
     return !Interface->hasDefinition();
   }
   }
 }
 
+bool Type::isSizelessBuiltinType() const {
+  if (const BuiltinType *BT = getAs<BuiltinType>()) {
+    switch (BT->getKind()) {
+    case BuiltinType::AArch64SVEInt8:
+    case BuiltinType::AArch64SVEInt16:
+      return true;
+    default:
+      return false;
+    }
+  }
+  return false;
+}
+
+bool Type::isSizelessType() const {
+  return isSizelessBuiltinType();
+}
+
 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);
 }
 
#include "clang/Basic/OpenCLImageTypes.def"
   case OCLClkEvent:
     return "clk_event_t";
   case OCLQueue:
     return "queue_t";
   case OCLReserveID:
     return "reserve_id_t";
   case OMPArraySection:
     return "<OpenMP array section type>";
+  // NOT intended for commit, just a crutch to provide some sizeless types.
+  // The real SVE support will include a way of defining target-specific
+  // types like these.
+  case AArch64SVEInt8:
+    return "__SVInt8_t";
+  case AArch64SVEInt16:
+    return "__SVInt16_t";
   }
 
   llvm_unreachable("Invalid builtin type.");
 }
 
 QualType QualType::getNonLValueExprType(const ASTContext &Context) const {
   if (const auto *RefType = getTypePtr()->getAs<ReferenceType>())
     return RefType->getPointeeType();
#include "clang/Basic/OpenCLImageTypes.def"
     case BuiltinType::OCLSampler:
     case BuiltinType::OCLEvent:
     case BuiltinType::OCLClkEvent:
     case BuiltinType::OCLQueue:
     case BuiltinType::OCLReserveID:
     case BuiltinType::BuiltinFn:
     case BuiltinType::NullPtr:
     case BuiltinType::OMPArraySection:
+    // NOT intended for commit, just a crutch to provide some sizeless types.
+    // The real SVE support will include a way of defining target-specific
+    // types like these.
+    case BuiltinType::AArch64SVEInt8:
+    case BuiltinType::AArch64SVEInt16:
       return false;
     }
     llvm_unreachable("unknown builtin type");
 
   // Non-pointer types.
   case Type::Complex:
   case Type::LValueReference:
   case Type::RValueReference:

lib/AST/TypeLoc.cpp

TypeSpecifierType BuiltinTypeLoc::getWrittenTypeSpec() const {
   case BuiltinType::LongLong:
   case BuiltinType::Int128:
   case BuiltinType::Half:
   case BuiltinType::Float:
   case BuiltinType::Double:
   case BuiltinType::LongDouble:
   case BuiltinType::Float16:
   case BuiltinType::Float128:
+  // NOT intended for commit, just a crutch to provide some sizeless types.
+  // The real SVE support will include a way of defining target-specific
+  // types like these.
+  case BuiltinType::AArch64SVEInt8:
+  case BuiltinType::AArch64SVEInt16:
     llvm_unreachable("Builtin type needs extra local data!");
     // Fall through, if the impossible happens.
       
   case BuiltinType::NullPtr:
   case BuiltinType::Overload:
   case BuiltinType::Dependent:
   case BuiltinType::BoundMember:
   case BuiltinType::UnknownAny:

lib/CodeGen/CGDebugInfo.cpp

#include "clang/Basic/OpenCLImageTypes.def"
   case BuiltinType::Double:
     // FIXME: For targets where long double and __float128 have the same size,
     // they are currently indistinguishable in the debugger without some
     // special treatment. However, there is currently no consensus on encoding
     // and this should be updated once a DWARF encoding exists for distinct
     // floating point types of the same size.
     Encoding = llvm::dwarf::DW_ATE_float;
     break;
+  // NOT intended for commit, just a crutch to provide some sizeless types.
+  // The real SVE support will include a way of defining target-specific
+  // types like these.
+  case BuiltinType::AArch64SVEInt8:
+  case BuiltinType::AArch64SVEInt16:
+    llvm_unreachable("codegen of SVE types not supported yet");
   }
 
   switch (BT->getKind()) {
   case BuiltinType::Long:
     BTName = "long int";
     break;
   case BuiltinType::LongLong:
     BTName = "long long int";

lib/CodeGen/CodeGenTypes.cpp

case BuiltinType::OCLReserveID:
       break;
     
     case BuiltinType::Dependent:
 #define BUILTIN_TYPE(Id, SingletonId)
 #define PLACEHOLDER_TYPE(Id, SingletonId) \
     case BuiltinType::Id:
 #include "clang/AST/BuiltinTypes.def"
       llvm_unreachable("Unexpected placeholder builtin type!");
+
+    // NOT intended for commit, just a crutch to provide some sizeless types.
+    // The real SVE support will include a way of defining target-specific
+    // types like these.
+    case BuiltinType::AArch64SVEInt8:
+    case BuiltinType::AArch64SVEInt16:
+      llvm_unreachable("No LLVM equivalent of SVE types yet");
     }
     break;
   }
   case Type::Auto:
   case Type::DeducedTemplateSpecialization:
     llvm_unreachable("Unexpected undeduced type!");
   case Type::Complex: {
     llvm::Type *EltTy = ConvertType(cast<ComplexType>(Ty)->getElementType());

lib/CodeGen/ItaniumCXXABI.cpp

 #define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
     case BuiltinType::Id:
 #include "clang/Basic/OpenCLImageTypes.def"
     case BuiltinType::OCLSampler:
     case BuiltinType::OCLEvent:
     case BuiltinType::OCLClkEvent:
     case BuiltinType::OCLQueue:
     case BuiltinType::OCLReserveID:
+    // NOT intended for commit, just a crutch to provide some sizeless types.
+    // The real SVE support will include a way of defining target-specific
+    // types like these.
+    case BuiltinType::AArch64SVEInt8:
+    case BuiltinType::AArch64SVEInt16:
       return false;
 
     case BuiltinType::Dependent:
 #define BUILTIN_TYPE(Id, SingletonId)
 #define PLACEHOLDER_TYPE(Id, SingletonId) \
     case BuiltinType::Id:
 #include "clang/AST/BuiltinTypes.def"
       llvm_unreachable("asking for RRTI for a placeholder type!");

lib/Index/USRGeneration.cpp

#include "clang/Basic/OpenCLImageTypes.def"
           IgnoreResults = true;
           return;
         case BuiltinType::ObjCId:
           c = 'o'; break;
         case BuiltinType::ObjCClass:
           c = 'O'; break;
         case BuiltinType::ObjCSel:
           c = 'e'; break;
+        // NOT intended for commit, just a crutch to provide some
+        // sizeless types.  The real SVE support will include a way of
+        // defining target-specific types like these.
+        case BuiltinType::AArch64SVEInt8:
+        case BuiltinType::AArch64SVEInt16:
+          llvm_unreachable("USR not supported for SVE types");
       }
       Out << c;
       return;
     }
 
     // If we have already seen this (non-built-in) type, use a substitution
     // encoding.
     llvm::DenseMap<const Type *, unsigned>::iterator Substitution

lib/Sema/Sema.cpp

if (getLangOpts().MSVCCompat) {
     if (getLangOpts().CPlusPlus &&
         IdResolver.begin(&Context.Idents.get("type_info")) == IdResolver.end())
       PushOnScopeChains(Context.buildImplicitRecord("type_info", TTK_Class),
                         TUScope);
 
     addImplicitTypedef("size_t", Context.getSizeType());
   }
 
+  // NOT intended for commit, just a crutch to provide some sizeless types.
+  // The real SVE support will include a way of defining target-specific
+  // types like these.
+  addImplicitTypedef("__SVInt8_t", Context.AArch64SVEInt8Ty);
+  addImplicitTypedef("__SVInt16_t", Context.AArch64SVEInt16Ty);
+
   // Initialize predefined OpenCL types and supported extensions and (optional)
   // core features.
   if (getLangOpts().OpenCL) {
     getOpenCLOptions().addSupport(Context.getTargetInfo().getSupportedOpenCLOpts());
     getOpenCLOptions().enableSupportedCore(getLangOpts().OpenCLVersion);
     addImplicitTypedef("sampler_t", Context.OCLSamplerTy);
     addImplicitTypedef("event_t", Context.OCLEventTy);
     if (getLangOpts().OpenCLVersion >= 200) {

lib/Serialization/ASTCommon.cpp

case BuiltinType::OCLReserveID:
     ID = PREDEF_TYPE_RESERVE_ID_ID;
     break;
   case BuiltinType::BuiltinFn:
     ID = PREDEF_TYPE_BUILTIN_FN;
     break;
   case BuiltinType::OMPArraySection:
     ID = PREDEF_TYPE_OMP_ARRAY_SECTION;
     break;
+  // NOT intended for commit, just a crutch to provide some sizeless types.
+  // The real SVE support will include a way of defining target-specific
+  // types like these.
+  case BuiltinType::AArch64SVEInt8:
+    ID = PREDEF_TYPE_AARCH64_SVE_INT8;
+    break;
+  case BuiltinType::AArch64SVEInt16:
+    ID = PREDEF_TYPE_AARCH64_SVE_INT16;
+    break;
   }
 
   return TypeIdx(ID);
 }
 
 unsigned serialization::ComputeHash(Selector Sel) {
   unsigned N = Sel.getNumArgs();
   if (N == 0)

lib/Serialization/ASTReader.cpp

case PREDEF_TYPE_ARC_UNBRIDGED_CAST:
       T = Context.ARCUnbridgedCastTy;
       break;
     case PREDEF_TYPE_BUILTIN_FN:
       T = Context.BuiltinFnTy;
       break;
     case PREDEF_TYPE_OMP_ARRAY_SECTION:
       T = Context.OMPArraySectionTy;
       break;
+    // NOT intended for commit, just a crutch to provide some sizeless types.
+    // The real SVE support will include a way of defining target-specific
+    // types like these.
+    case PREDEF_TYPE_AARCH64_SVE_INT8:
+      T = Context.AArch64SVEInt8Ty;
+      break;
+    case PREDEF_TYPE_AARCH64_SVE_INT16:
+      T = Context.AArch64SVEInt16Ty;
+      break;
     }
 
     assert(!T.isNull() && "Unknown predefined type");
     return T.withFastQualifiers(FastQuals);
   }
 
   Index -= NUM_PREDEF_TYPE_IDS;
   assert(Index < TypesLoaded.size() && "Type index out-of-range");

tools/libclang/CIndex.cpp

#include "clang/Basic/OpenCLImageTypes.def"
   case BuiltinType::OCLQueue:
   case BuiltinType::OCLReserveID:
 #define BUILTIN_TYPE(Id, SingletonId)
 #define SIGNED_TYPE(Id, SingletonId) case BuiltinType::Id:
 #define UNSIGNED_TYPE(Id, SingletonId) case BuiltinType::Id:
 #define FLOATING_TYPE(Id, SingletonId) case BuiltinType::Id:
 #define PLACEHOLDER_TYPE(Id, SingletonId) case BuiltinType::Id:
 #include "clang/AST/BuiltinTypes.def"
+  // NOT intended for commit, just a crutch to provide some sizeless types.
+  // The real SVE support will include a way of defining target-specific
+  // types like these.
+  case BuiltinType::AArch64SVEInt8:
+  case BuiltinType::AArch64SVEInt16:
     break;
 
   case BuiltinType::ObjCId:
     VisitType = Context.getObjCIdType();
     break;
 
   case BuiltinType::ObjCClass:
     VisitType = Context.getObjCClassType();