PR8901: attribute "mode" rejected for enums and dependent types

[• d.zobnin.bugzilla]

Summary

Allow "mode" attribute for enum types, except for vector modes, for compatibility with GCC. Support "mode" attribute with dependent types.

[• d.zobnin.bugzilla]

Updated the patch after committed fix for http://reviews.llvm.org/D16301 (r258213).

This patch:

1. Adds "Enum" Subject to 'mode' attribute to be able to compile code like "typedef enum { X } attribute((mode(QI))) T;"
2. Moves handling of the attribute to a new Sema's method in order to support 'mode' attribute on dependent types;
3. Adds several cases to the tests (both for templates and non-dependent types).

Please take a look.

[• d.zobnin.bugzilla]

Friendly ping, please take a look.

[aaron.ballman]

Aside from one nitpick about the diagnostic wording, this LGTM.

include/clang/Basic/Attr.td

882 ↗

(On Diff #45401)

One of these days I may have to come up with a more general solution for this sort of subject list. :-(

include/clang/Basic/DiagnosticSemaKinds.td

2856 ↗

(On Diff #45401)

s/enumeral/enumeration

[• d.zobnin.bugzilla]

Thanks for the review!

Only updated the text of diagnostics, NFC.

cfe/trunk/include/clang/Basic/Attr.td

let Args = [EnumArgument<"Interrupt", "InterruptType",
                             "hw4", "hw5", "eic", "eic"]
                            >];
   let ParseKind = "Interrupt";
   let Documentation = [MipsInterruptDocs];
 }
 
 def Mode : Attr {
   let Spellings = [GCC<"mode">];
-  let Subjects = SubjectList<[Var, TypedefName, Field], ErrorDiag,
-                             "ExpectedVariableFieldOrTypedef">;
+  let Subjects = SubjectList<[Var, Enum, TypedefName, Field], ErrorDiag,
+                             "ExpectedVariableEnumFieldOrTypedef">;
   let Args = [IdentifierArgument<"Mode">];
   let Documentation = [Undocumented];
 }
 
 def Naked : InheritableAttr {
   let Spellings = [GCC<"naked">, Declspec<"naked">];
   let Subjects = SubjectList<[Function]>;
   let Documentation = [Undocumented];

cfe/trunk/include/clang/Basic/DiagnosticSemaKinds.td

def warn_attribute_wrong_decl_type : Warning<
   "variables and typedefs|thread-local variables|"
   "variables and fields|variables, data members and tag types|"
   "types and namespaces|Objective-C interfaces|methods and properties|"
   "struct or union|struct, union or class|types|"
   "Objective-C instance methods|init methods of interface or class extension declarations|"
   "variables, functions and classes|Objective-C protocols|"
   "functions and global variables|structs, unions, and typedefs|structs and typedefs|"
   "interface or protocol declarations|kernel functions|non-K&R-style functions|"
-  "variables, fields and typedefs}1">,
+  "variables, enums, fields and typedefs}1">,
   InGroup<IgnoredAttributes>;
 def err_attribute_wrong_decl_type : Error<warn_attribute_wrong_decl_type.Text>;
 def warn_type_attribute_wrong_type : Warning<
   "'%0' only applies to %select{function|pointer|"
   "Objective-C object or block pointer}1 types; type here is %2">,
   InGroup<IgnoredAttributes>;
 def warn_incomplete_encoded_type : Warning<
   "encoding of %0 type is incomplete because %1 component has unknown encoding">,

 def err_mode_wrong_type : Error<
   "type of machine mode does not match type of base type">;
 def warn_vector_mode_deprecated : Warning<
   "specifying vector types with the 'mode' attribute is deprecated; "
   "use the 'vector_size' attribute instead">,
   InGroup<DeprecatedAttributes>;
 def err_complex_mode_vector_type : Error<
   "type of machine mode does not support base vector types">;
+def err_enum_mode_vector_type : Error<
+  "mode %0 is not supported for enumeration types">;
 def warn_attribute_nonnull_no_pointers : Warning<
   "'nonnull' attribute applied to function with no pointer arguments">,
   InGroup<IgnoredAttributes>;
 def warn_attribute_nonnull_parm_no_args : Warning<
   "'nonnull' attribute when used on parameters takes no arguments">,
   InGroup<IgnoredAttributes>;
 def warn_attribute_sentinel_named_arguments : Warning<
   "'sentinel' attribute requires named arguments">,

cfe/trunk/include/clang/Sema/AttributeList.h

enum AttributeDeclKind {
   ExpectedFunctionVariableOrClass,
   ExpectedObjectiveCProtocol,
   ExpectedFunctionGlobalVarMethodOrProperty,
   ExpectedStructOrUnionOrTypedef,
   ExpectedStructOrTypedef,
   ExpectedObjectiveCInterfaceOrProtocol,
   ExpectedKernelFunction,
   ExpectedFunctionWithProtoType,
-  ExpectedVariableFieldOrTypedef
+  ExpectedVariableEnumFieldOrTypedef
 };
 
 }  // end namespace clang
 
 #endif

cfe/trunk/include/clang/Sema/Sema.h

   void AddAlignValueAttr(SourceRange AttrRange, Decl *D, Expr *E,
                          unsigned SpellingListIndex);
 
   /// AddLaunchBoundsAttr - Adds a launch_bounds attribute to a particular
   /// declaration.
   void AddLaunchBoundsAttr(SourceRange AttrRange, Decl *D, Expr *MaxThreads,
                            Expr *MinBlocks, unsigned SpellingListIndex);
 
+  /// AddModeAttr - Adds a mode attribute to a particular declaration.
+  void AddModeAttr(SourceRange AttrRange, Decl *D, IdentifierInfo *Name,
+                   unsigned SpellingListIndex, bool InInstantiation = false);
+
   //===--------------------------------------------------------------------===//
   // C++ Coroutines TS
   //
   ExprResult ActOnCoawaitExpr(Scope *S, SourceLocation KwLoc, Expr *E);
   ExprResult ActOnCoyieldExpr(Scope *S, SourceLocation KwLoc, Expr *E);
   StmtResult ActOnCoreturnStmt(SourceLocation KwLoc, Expr *E);
 
   ExprResult BuildCoawaitExpr(SourceLocation KwLoc, Expr *E);

cfe/trunk/lib/Sema/SemaDeclAttr.cpp

Diag(RD->getDefinition()->getLocation(), diag::note_defined_here)
       << RD->getNameAsString();
   return true;
 }
 
 /// parseModeAttrArg - Parses attribute mode string and returns parsed type
 /// attribute.
 static void parseModeAttrArg(Sema &S, StringRef Str, unsigned &DestWidth,
                              bool &IntegerMode, bool &ComplexMode) {
+  IntegerMode = true;
+  ComplexMode = false;
   switch (Str.size()) {
   case 2:
     switch (Str[0]) {
     case 'Q':
       DestWidth = 8;
       break;
     case 'H':
       DestWidth = 16;
static void handleModeAttr(Sema &S, Decl *D, const AttributeList &Attr) {
   // the width of an int or unsigned int to the specified size.
   if (!Attr.isArgIdent(0)) {
     S.Diag(Attr.getLoc(), diag::err_attribute_argument_type) << Attr.getName()
       << AANT_ArgumentIdentifier;
     return;
   }
 
   IdentifierInfo *Name = Attr.getArgAsIdent(0)->Ident;
-  StringRef Str = Name->getName();
 
+  S.AddModeAttr(Attr.getRange(), D, Name, Attr.getAttributeSpellingListIndex());
+}
+
+void Sema::AddModeAttr(SourceRange AttrRange, Decl *D, IdentifierInfo *Name,
+                       unsigned SpellingListIndex, bool InInstantiation) {
+  StringRef Str = Name->getName();
   normalizeName(Str);
+  SourceLocation AttrLoc = AttrRange.getBegin();
 
   unsigned DestWidth = 0;
   bool IntegerMode = true;
   bool ComplexMode = false;
   llvm::APInt VectorSize(64, 0);
   if (Str.size() >= 4 && Str[0] == 'V') {
     // Minimal length of vector mode is 4: 'V' + NUMBER(>=1) + TYPE(>=2).
     size_t StrSize = Str.size();
     size_t VectorStringLength = 0;
     while ((VectorStringLength + 1) < StrSize &&
            isdigit(Str[VectorStringLength + 1]))
       ++VectorStringLength;
     if (VectorStringLength &&
         !Str.substr(1, VectorStringLength).getAsInteger(10, VectorSize) &&
         VectorSize.isPowerOf2()) {
-      parseModeAttrArg(S, Str.substr(VectorStringLength + 1), DestWidth,
+      parseModeAttrArg(*this, Str.substr(VectorStringLength + 1), DestWidth,
                        IntegerMode, ComplexMode);
-      S.Diag(Attr.getLoc(), diag::warn_vector_mode_deprecated);
+      // Avoid duplicate warning from template instantiation.
+      if (!InInstantiation)
+        Diag(AttrLoc, diag::warn_vector_mode_deprecated);
     } else {
       VectorSize = 0;
     }
   }
 
   if (!VectorSize)
-    parseModeAttrArg(S, Str, DestWidth, IntegerMode, ComplexMode);
+    parseModeAttrArg(*this, Str, DestWidth, IntegerMode, ComplexMode);
+
+  // FIXME: Sync this with InitializePredefinedMacros; we need to match int8_t
+  // and friends, at least with glibc.
+  // FIXME: Make sure floating-point mappings are accurate
+  // FIXME: Support XF and TF types
+  if (!DestWidth) {
+    Diag(AttrLoc, diag::err_machine_mode) << 0 /*Unknown*/ << Name;
+    return;
+  }
 
   QualType OldTy;
   if (TypedefNameDecl *TD = dyn_cast<TypedefNameDecl>(D))
     OldTy = TD->getUnderlyingType();
-  else
+  else if (EnumDecl *ED = dyn_cast<EnumDecl>(D)) {
+    // Something like 'typedef enum { X } __attribute__((mode(XX))) T;'.
+    // Try to get type from enum declaration, default to int.
+    OldTy = ED->getIntegerType();
+    if (OldTy.isNull())
+      OldTy = Context.IntTy;
+  } else
     OldTy = cast<ValueDecl>(D)->getType();
 
+  if (OldTy->isDependentType()) {
+    D->addAttr(::new (Context)
+               ModeAttr(AttrRange, Context, Name, SpellingListIndex));
+    return;
+  }
+
   // Base type can also be a vector type (see PR17453).
   // Distinguish between base type and base element type.
   QualType OldElemTy = OldTy;
   if (const VectorType *VT = OldTy->getAs<VectorType>())
     OldElemTy = VT->getElementType();
 
-  if (!OldElemTy->getAs<BuiltinType>() && !OldElemTy->isComplexType())
-    S.Diag(Attr.getLoc(), diag::err_mode_not_primitive);
+  // GCC allows 'mode' attribute on enumeration types (even incomplete), except
+  // for vector modes. So, 'enum X __attribute__((mode(QI)));' forms a complete
+  // type, 'enum { A } __attribute__((mode(V4SI)))' is rejected.
+  if ((isa<EnumDecl>(D) || OldElemTy->getAs<EnumType>()) &&
+      VectorSize.getBoolValue()) {
+    Diag(AttrLoc, diag::err_enum_mode_vector_type) << Name << AttrRange;
+    return;
+  }
+  bool IntegralOrAnyEnumType =
+      OldElemTy->isIntegralOrEnumerationType() || OldElemTy->getAs<EnumType>();
+
+  if (!OldElemTy->getAs<BuiltinType>() && !OldElemTy->isComplexType() &&
+      !IntegralOrAnyEnumType)
+    Diag(AttrLoc, diag::err_mode_not_primitive);
   else if (IntegerMode) {
-    if (!OldElemTy->isIntegralOrEnumerationType())
-      S.Diag(Attr.getLoc(), diag::err_mode_wrong_type);
+    if (!IntegralOrAnyEnumType)
+      Diag(AttrLoc, diag::err_mode_wrong_type);
   } else if (ComplexMode) {
     if (!OldElemTy->isComplexType())
-      S.Diag(Attr.getLoc(), diag::err_mode_wrong_type);
+      Diag(AttrLoc, diag::err_mode_wrong_type);
   } else {
     if (!OldElemTy->isFloatingType())
-      S.Diag(Attr.getLoc(), diag::err_mode_wrong_type);
-  }
-
-  // FIXME: Sync this with InitializePredefinedMacros; we need to match int8_t
-  // and friends, at least with glibc.
-  // FIXME: Make sure floating-point mappings are accurate
-  // FIXME: Support XF and TF types
-  if (!DestWidth) {
-    S.Diag(Attr.getLoc(), diag::err_machine_mode) << 0 /*Unknown*/ << Name;
-    return;
+      Diag(AttrLoc, diag::err_mode_wrong_type);
   }
 
   QualType NewElemTy;
 
   if (IntegerMode)
-    NewElemTy = S.Context.getIntTypeForBitwidth(
-        DestWidth, OldElemTy->isSignedIntegerType());
+    NewElemTy = Context.getIntTypeForBitwidth(DestWidth,
+                                              OldElemTy->isSignedIntegerType());
   else
-    NewElemTy = S.Context.getRealTypeForBitwidth(DestWidth);
+    NewElemTy = Context.getRealTypeForBitwidth(DestWidth);
 
   if (NewElemTy.isNull()) {
-    S.Diag(Attr.getLoc(), diag::err_machine_mode) << 1 /*Unsupported*/ << Name;
+    Diag(AttrLoc, diag::err_machine_mode) << 1 /*Unsupported*/ << Name;
     return;
   }
 
   if (ComplexMode) {
-    NewElemTy = S.Context.getComplexType(NewElemTy);
+    NewElemTy = Context.getComplexType(NewElemTy);
   }
 
   QualType NewTy = NewElemTy;
   if (VectorSize.getBoolValue()) {
-    NewTy = S.Context.getVectorType(NewTy, VectorSize.getZExtValue(),
-                                    VectorType::GenericVector);
+    NewTy = Context.getVectorType(NewTy, VectorSize.getZExtValue(),
   } else if (const VectorType *OldVT = OldTy->getAs<VectorType>()) {
     // Complex machine mode does not support base vector types.
     if (ComplexMode) {
-      S.Diag(Attr.getLoc(), diag::err_complex_mode_vector_type);
+      Diag(AttrLoc, diag::err_complex_mode_vector_type);
       return;
     }
-    unsigned NumElements = S.Context.getTypeSize(OldElemTy) *
+    unsigned NumElements = Context.getTypeSize(OldElemTy) *
                            OldVT->getNumElements() /
-                           S.Context.getTypeSize(NewElemTy);
+                           Context.getTypeSize(NewElemTy);
     NewTy =
-        S.Context.getVectorType(NewElemTy, NumElements, OldVT->getVectorKind());
+        Context.getVectorType(NewElemTy, NumElements, OldVT->getVectorKind());
   }
 
   if (NewTy.isNull()) {
-    S.Diag(Attr.getLoc(), diag::err_mode_wrong_type);
+    Diag(AttrLoc, diag::err_mode_wrong_type);
     return;
   }
 
   // Install the new type.
   if (TypedefNameDecl *TD = dyn_cast<TypedefNameDecl>(D))
     TD->setModedTypeSourceInfo(TD->getTypeSourceInfo(), NewTy);
+  else if (EnumDecl *ED = dyn_cast<EnumDecl>(D))
+    ED->setIntegerType(NewTy);
   else
     cast<ValueDecl>(D)->setType(NewTy);
 
-  D->addAttr(::new (S.Context)
-             ModeAttr(Attr.getRange(), S.Context, Name,
-                      Attr.getAttributeSpellingListIndex()));
+  D->addAttr(::new (Context)
+             ModeAttr(AttrRange, Context, Name, SpellingListIndex));
 }
 
 static void handleNoDebugAttr(Sema &S, Decl *D, const AttributeList &Attr) {
   if (const VarDecl *VD = dyn_cast<VarDecl>(D)) {
     if (!VD->hasGlobalStorage())
       S.Diag(Attr.getLoc(),
              diag::warn_attribute_requires_functions_or_static_globals)
         << Attr.getName();

cfe/trunk/lib/Sema/SemaTemplateInstantiateDecl.cpp

if (Result.isInvalid())
       return;
     MinBlocks = Result.getAs<Expr>();
   }
 
   S.AddLaunchBoundsAttr(Attr.getLocation(), New, MaxThreads, MinBlocks,
                         Attr.getSpellingListIndex());
 }
 
+static void
+instantiateDependentModeAttr(Sema &S,
+                             const MultiLevelTemplateArgumentList &TemplateArgs,
+                             const ModeAttr &Attr, Decl *New) {
+  S.AddModeAttr(Attr.getRange(), New, Attr.getMode(),
+                Attr.getSpellingListIndex(), /*InInstantiation=*/true);
+}
+
 void Sema::InstantiateAttrs(const MultiLevelTemplateArgumentList &TemplateArgs,
                             const Decl *Tmpl, Decl *New,
                             LateInstantiatedAttrVec *LateAttrs,
                             LocalInstantiationScope *OuterMostScope) {
   for (const auto *TmplAttr : Tmpl->attrs()) {
     // FIXME: This should be generalized to more than just the AlignedAttr.
     const AlignedAttr *Aligned = dyn_cast<AlignedAttr>(TmplAttr);
     if (Aligned && Aligned->isAlignmentDependent()) {
for (const auto *TmplAttr : Tmpl->attrs()) {
 
     if (const CUDALaunchBoundsAttr *CUDALaunchBounds =
             dyn_cast<CUDALaunchBoundsAttr>(TmplAttr)) {
       instantiateDependentCUDALaunchBoundsAttr(*this, TemplateArgs,
                                                *CUDALaunchBounds, New);
       continue;
     }
 
+    if (const ModeAttr *Mode = dyn_cast<ModeAttr>(TmplAttr)) {
+      instantiateDependentModeAttr(*this, TemplateArgs, *Mode, New);
+      continue;
+    }
+
     // Existing DLL attribute on the instantiation takes precedence.
     if (TmplAttr->getKind() == attr::DLLExport ||
         TmplAttr->getKind() == attr::DLLImport) {
       if (New->hasAttr<DLLExportAttr>() || New->hasAttr<DLLImportAttr>()) {
         continue;
       }
     }
 

cfe/trunk/test/CodeGen/attr-mode-enums.c

+// RUN: %clang_cc1 -triple x86_64-unknown-unknown -emit-llvm %s -o - | FileCheck %s
+
+// Test checks that 'mode' attribute is handled correctly with enums, i. e. code
+//   1. "typedef enum { A } __attribute__((mode(HI))) T;" is accepted,
+//   2. "enum X __attribute__((mode(QI))) var;" forms a complete integer type.
+
+int main() {
+  // CHECK: [[X1:%.+]] = alloca i8
+  enum { A1, B1 } __attribute__((mode(QI))) x1 = A1;
+
+  // CHECK: [[X2:%.+]] = alloca i16
+  enum { A2, B2 } x2 __attribute__((mode(HI))) = B2;
+
+  // CHECK: [[X3:%.+]] = alloca i32
+  typedef enum { A3, B3 } __attribute__((mode(SI))) T3;
+  T3 x3 = A3;
+
+  // CHECK: [[X4:%.+]] = alloca i64
+  typedef enum { A4, B4 } T4 __attribute__((mode(DI)));
+  T4 x4 = B4;
+
+  // CHECK: [[X5:%.+]] = alloca i8
+  typedef enum __attribute__((mode(QI))) { A5, B5 } T5;
+  T5 x5 = A5;
+
+  // CHECK: [[X6:%.+]] = alloca i8
+  typedef enum X __attribute__((mode(QI))) T6;
+  T6 x6;
+
+  // CHECK: [[X7:%.+]] = alloca i128
+  enum { A7, B7 } __attribute__((mode(TI))) x7 = A7;
+
+  // CHECK: [[X8:%.+]] = alloca i8
+  enum __attribute__((mode(QI))) { A8, B8 } x8 = B8;
+
+  // CHECK: store i8 0, i8* [[X1]]
+  // CHECK: store i16 1, i16* [[X2]]
+  // CHECK: store i32 0, i32* [[X3]]
+  // CHECK: store i64 1, i64* [[X4]]
+  // CHECK: store i8 0, i8* [[X5]]
+  // CHECK: store i128 0, i128* [[X7]]
+  // CHECK: store i8 1, i8* [[X8]]
+
+  return x1 + x2 + x3 + x4 + x5 + x6 + x7 + x8;
+}

cfe/trunk/test/CodeGenCXX/attr-mode-vector-types-tmpl.cpp

+// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu %s -emit-llvm -o - | FileCheck %s
+
+template <class T>
+void CheckIntScalarTypes() {
+  // T will be substituted with 'int' and 'enum' types.
+
+  typedef T __attribute__((mode(QI))) T1;
+  typedef T __attribute__((mode(HI))) T2;
+  typedef T __attribute__((mode(SI))) T3;
+  typedef T __attribute__((mode(DI))) T4;
+
+  T1 a1;
+  T2 a2;
+  T3 a3;
+  T4 a4;
+}
+
+template <class T>
+void CheckIntVectorTypes() {
+  // T will be substituted with 'int'.
+
+  typedef int __attribute__((mode(QI))) __attribute__((vector_size(8)))  VT_11;
+  typedef T   __attribute__((mode(V8QI)))                                VT_12;
+  typedef int __attribute__((mode(SI))) __attribute__((vector_size(16))) VT_21;
+  typedef T   __attribute__((mode(V4SI)))                                VT_22;
+  typedef int __attribute__((mode(DI))) __attribute__((vector_size(64))) VT_31;
+  typedef T   __attribute__((mode(V8DI)))                                VT_32;
+
+  VT_11 v11;
+  VT_12 v12;
+
+  VT_21 v21;
+  VT_22 v22;
+
+  VT_31 v31;
+  VT_32 v32;
+}
+
+template <class T>
+void CheckFloatVectorTypes() {
+  // T will be substituted with 'float'.
+
+  typedef float __attribute__((mode(SF))) __attribute__((vector_size(128))) VT_41;
+  typedef T     __attribute__((mode(V32SF)))                                VT_42;
+  typedef float __attribute__((mode(DF))) __attribute__((vector_size(256))) VT_51;
+  typedef T     __attribute__((mode(V32DF)))                                VT_52;
+
+  VT_41 v41;
+  VT_42 v42;
+
+  VT_51 v51;
+  VT_52 v52;
+}
+
+template <class T>
+void CheckInstantiationWithModedType() {
+  T x1;
+}
+
+typedef enum { A1, B1 }                       EnumTy;
+typedef int __attribute__((mode(DI)))         Int64Ty1;
+typedef enum __attribute__((mode(DI))) { A2 } Int64Ty2;
+typedef int __attribute__((mode(V8HI)))       IntVecTy1;
+
+void test() {
+
+  // CHECK: define {{.*}} void @_Z19CheckIntScalarTypesIiEvv()
+  // CHECK: %{{.+}} = alloca i8
+  // CHECK: %{{.+}} = alloca i16
+  // CHECK: %{{.+}} = alloca i32
+  // CHECK: %{{.+}} = alloca i64
+  CheckIntScalarTypes<int>();
+
+  // CHECK: define {{.*}} void @_Z19CheckIntScalarTypesI6EnumTyEvv()
+  // CHECK: %{{.+}} = alloca i8
+  // CHECK: %{{.+}} = alloca i16
+  // CHECK: %{{.+}} = alloca i32
+  // CHECK: %{{.+}} = alloca i64
+  CheckIntScalarTypes<EnumTy>();
+
+  // CHECK: define {{.*}} void @_Z19CheckIntVectorTypesIiEvv()
+  // CHECK: %{{.+}} = alloca <8 x i8>
+  // CHECK: %{{.+}} = alloca <8 x i8>
+  // CHECK: %{{.+}} = alloca <4 x i32>
+  // CHECK: %{{.+}} = alloca <4 x i32>
+  // CHECK: %{{.+}} = alloca <8 x i64>
+  // CHECK: %{{.+}} = alloca <8 x i64>
+  CheckIntVectorTypes<int>();
+
+  // CHECK: define {{.*}} void @_Z21CheckFloatVectorTypesIfEvv()
+  // CHECK: %{{.+}} = alloca <32 x float>
+  // CHECK: %{{.+}} = alloca <32 x float>
+  // CHECK: %{{.+}} = alloca <32 x double>
+  // CHECK: %{{.+}} = alloca <32 x double>
+  CheckFloatVectorTypes<float>();
+
+  // CHECK: define {{.*}} void @_Z31CheckInstantiationWithModedTypeIlEvv()
+  // CHECK: [[X1:%.+]] = alloca i64
+  CheckInstantiationWithModedType<Int64Ty1>();
+
+  // CHECK: define {{.*}} void @_Z31CheckInstantiationWithModedTypeI8Int64Ty2Evv()
+  // CHECK: [[X1]] = alloca i64
+  CheckInstantiationWithModedType<Int64Ty2>();
+
+  // CHECK: define {{.*}} void @_Z31CheckInstantiationWithModedTypeIDv8_sEvv()
+  // CHECK: [[X1]] = alloca <8 x i16>
+  CheckInstantiationWithModedType<IntVecTy1>();
+}

cfe/trunk/test/Sema/attr-mode-enums.c

+// RUN: %clang_cc1 -fsyntax-only -verify %s
+
+// Test checks that 'mode' attribute is handled correctly with enums, i. e. code
+//   1. "typedef enum { A } __attribute__((mode(HI))) T;" is accepted,
+//   2. "enum X __attribute__((mode(QI))) var;" forms a complete integer type.
+//   3. "enum { A } __attribute__((mode(V4SI))) var;" is not accepted (vector mode).
+
+typedef enum { E4 } EnumType;
+
+int main() {
+  // Vector mode are not allowed with enums.
+  typedef enum { E1 } __attribute__((mode(V4QI))) RejectedType1; // expected-error{{mode 'V4QI' is not supported for enumeration types}}
+  // expected-warning@-1{{specifying vector types with the 'mode' attribute is deprecated}}
+  typedef enum __attribute__((mode(V8HI))) { E2 } RejectedType2; // expected-error{{mode 'V8HI' is not supported for enumeration types}}
+                                                                 // expected-warning@-1{{deprecated}}
+  typedef enum E3 __attribute__((mode(V2SI))) RejectedType3; // expected-error{{mode 'V2SI' is not supported for enumeration types}}
+                                                             // expected-warning@-1{{deprecated}}
+  typedef EnumType __attribute__((mode(V4DI))) RejectedType4; // expected-error{{mode 'V4DI' is not supported for enumeration types}}
+                                                              // expected-warning@-1{{deprecated}}
+  EnumType v1 __attribute__((mode(V4QI))); // expected-error{{mode 'V4QI' is not supported for enumeration types}}
+                                           // expected-warning@-1{{deprecated}}
+  enum __attribute__((mode(V8HI))) { E5 } v2; // expected-error{{mode 'V8HI' is not supported for enumeration types}}
+                                              // expected-warning@-1{{deprecated}}
+
+  // Incomplete enums without mode attribute are not allowed.
+  typedef enum Y IncompleteYType; // expected-note{{forward declaration of 'enum Y'}}
+
+  enum X a1; // expected-error{{variable has incomplete type 'enum X'}}
+             // expected-note@-1{{forward declaration of 'enum X'}}
+  IncompleteYType a2; // expected-error{{variable has incomplete type 'IncompleteYType' (aka 'enum Y')}}
+
+  // OK with 'mode' attribute.
+  typedef enum Y __attribute__((mode(QI))) CompleteYType1;
+  typedef enum Y CompleteYType2 __attribute__((mode(HI)));
+  typedef enum { A1, B1 } __attribute__((mode(QI))) CompleteType3;
+  typedef enum { A2, B2 } CompleteType4 __attribute__((mode(QI)));
+  typedef enum __attribute__((mode(QI))) { A3, B3 } CompleteType5;
+
+  enum X __attribute__((mode(QI))) a3;
+  enum X a4 __attribute__((mode(HI)));
+  IncompleteYType __attribute__((mode(QI))) a5;
+  IncompleteYType a6 __attribute__((mode(HI)));
+  CompleteYType1 a7;
+  CompleteYType2 a8;
+  CompleteType3 a9;
+  CompleteType4 a10;
+  CompleteType5 a11;
+  enum __attribute__((mode(QI))) { A4, B4 } a12;
+
+  return 0;
+}

cfe/trunk/test/Sema/attr-mode.c

 typedef struct {int i,j,k;} invalid_4 __attribute((mode(SI))); // expected-error{{mode attribute only supported for integer and floating-point types}}
 typedef float invalid_5 __attribute((mode(SI))); // expected-error{{type of machine mode does not match type of base type}}
 typedef int invalid_6 __attribute__((mode(12)));  // expected-error{{'mode' attribute requires an identifier}}
 
 typedef unsigned unwind_word __attribute((mode(unwind_word)));
 
 int **__attribute((mode(QI)))* i32;  // expected-error{{mode attribute}}
 
-__attribute__((mode(QI))) int invalid_func() { return 1; } // expected-error{{'mode' attribute only applies to variables, fields and typedefs}}
-enum invalid_enum { A1 __attribute__((mode(QI))) }; // expected-error{{'mode' attribute only applies to variables, fields and typedefs}}
+__attribute__((mode(QI))) int invalid_func() { return 1; } // expected-error{{'mode' attribute only applies to variables, enums, fields and typedefs}}
+enum invalid_enum { A1 __attribute__((mode(QI))) }; // expected-error{{'mode' attribute only applies to variables, enums, fields and typedefs}}
 
 typedef _Complex double c32 __attribute((mode(SC)));
 int c32_test[sizeof(c32) == 8 ? 1 : -1];
 typedef _Complex float c64 __attribute((mode(DC)));
 
 #ifndef TEST_64BIT_PPC64 // Note, 'XC' mode is illegal for PPC64 machines.
 typedef _Complex float c80 __attribute((mode(XC)));
 #endif

cfe/trunk/test/SemaCXX/attr-mode-tmpl.cpp

+// RUN: %clang_cc1 -fsyntax-only -verify %s
+
+typedef enum { XX } EnumType;
+struct S { int x; };
+
+// Check enumerations. Vector modes on enum types must cause an error.
+template <class T>
+void CheckEnumerations() {
+  // Check that non-vector 'mode' attribute is OK with enumeration types.
+  typedef T __attribute__((mode(QI))) T1;
+  typedef T T2 __attribute__((mode(HI)));
+  typedef T __attribute__((mode(V8SI))) T3; // expected-error{{mode 'V8SI' is not supported for enumeration types}}
+  // expected-warning@-1{{specifying vector types with the 'mode' attribute is deprecated}}
+
+  typedef enum __attribute__((mode(HI))) { A4, B4 } T4;
+  typedef enum { A5, B5 } __attribute__((mode(SI))) T5;
+  typedef enum __attribute__((mode(V2SI))) { A6, B6 } T6; // expected-error{{mode 'V2SI' is not supported for enumeration types}}
+                                                          // expected-warning@-1{{deprecated}}
+  typedef enum { A7, B7 } __attribute__((mode(V2QI))) T7; // expected-error{{mode 'V2QI' is not supported for enumeration types}}
+                                                          // expected-warning@-1{{deprecated}}
+}
+
+// Check that attribute applies only for integer and floating-point types.
+// OK when instantiated with 'int', error with structure types, for example.
+template <class T>
+void CheckPrimitiveTypes() {
+  typedef T __attribute__((mode(QI))) T1;    // expected-error{{mode attribute only supported for integer and floating-point types}}
+  typedef T __attribute__((mode(V2SI))) VT1; // expected-error{{mode attribute only supported for integer and floating-point types}}
+  // expected-warning@-1{{specifying vector types with the 'mode' attribute is deprecated}}
+}
+
+// Check that attribute supports certain modes. Check that wrong machine modes
+// are NOT diagnosed twice during instantiation.
+template <class T>
+void CheckMachineMode() {
+  typedef T __attribute__((mode(QI))) T1; // expected-error{{type of machine mode does not match type of base type}}
+  typedef T __attribute__((mode(HI))) T2; // expected-error{{type of machine mode does not match type of base type}}
+  typedef T __attribute__((mode(SI))) T3; // expected-error{{type of machine mode does not match type of base type}}
+  typedef T __attribute__((mode(DI))) T4; // expected-error{{type of machine mode does not match type of base type}}
+  typedef T __attribute__((mode(SF))) T5; // expected-error2{{type of machine mode does not match type of base type}}
+  typedef T __attribute__((mode(DF))) T6; // expected-error2{{type of machine mode does not match type of base type}}
+  typedef T __attribute__((mode(II))) T7; // expected-error{{unknown machine mode}}
+  typedef T __attribute__((mode(12))) T8; // expected-error{{'mode' attribute requires an identifier}}
+}
+
+// Check attributes on function parameters.
+template <class T1, class T2>
+void CheckParameters(T1 __attribute__((mode(SI)))   paramSI,     // expected-note2{{ignored: substitution failure}}
+                     T1 __attribute__((mode(V4DI))) paramV4DI,   // expected-warning{{deprecated}}
+                     T2 __attribute__((mode(SF)))   paramSF,
+                     T2 __attribute__((mode(V4DF))) paramV4DF) { // expected-warning{{deprecated}}
+}
+
+
+// Check dependent structure.
+template <class T>
+struct TemplatedStruct {
+  // Check fields.
+  T __attribute__((mode(HI)))     x1;
+  T __attribute__((mode(V4HI)))   x2;         // expected-error{{mode 'V4HI' is not supported for enumeration types}}
+                                              // expected-warning@-1{{deprecated}}
+
+  // Check typedefs.
+  typedef T __attribute__((mode(DI)))   T1;
+  typedef T __attribute__((mode(V8DI))) T2;   // expected-error{{mode 'V8DI' is not supported for enumeration types}}
+                                              // expected-warning@-1{{deprecated}}
+
+  // Check parameters.
+  void f1(T __attribute__((mode(QI))) x) {}
+  void f2(T __attribute__((mode(SF))) x) {}   // expected-error2{{type of machine mode does not match type of base type}}
+  void f3(T __attribute__((mode(V4QI))) x) {} // expected-error{{mode 'V4QI' is not supported for enumeration types}}
+                                              // expected-warning@-1{{deprecated}}
+
+  // Check attribute on methods - it is invalid.
+  __attribute__((mode(QI))) T g1() { return 0; } // expected-error{{'mode' attribute only applies to variables, enums, fields and typedefs}}
+};
+
+
+
+int main() {
+  CheckEnumerations<int>();
+  CheckEnumerations<EnumType>(); // expected-note{{in instantiation of}}
+
+  CheckPrimitiveTypes<int>();
+  CheckPrimitiveTypes<S>();      // expected-note{{in instantiation of}}
+
+  // 'II' mode is unknown, no matter what we instantiate with.
+  CheckMachineMode<int>();       // expected-note{{in instantiation of}}
+  CheckMachineMode<EnumType>();  // expected-note{{in instantiation of}}
+  CheckMachineMode<float>();     // expected-note{{in instantiation of}}
+
+  int   __attribute__((mode(V4DI))) valV4DI; // expected-warning{{deprecated}}
+  float __attribute__((mode(V4DF))) valV4DF; // expected-warning{{deprecated}}
+  // OK.
+  CheckParameters<int, float>(0, valV4DI, 1.0, valV4DF);
+  // Enumeral type with vector mode is invalid.
+  CheckParameters<EnumType, float>(0, valV4DI, 1.0, valV4DF); // expected-error{{no matching function for call}}
+  // 'V4DF' mode with 'int' type is invalid.
+  CheckParameters<int, int>(0, valV4DI, 1, valV4DF); // expected-error{{no matching function for call}}
+
+  TemplatedStruct<int>      s1; // expected-note{{in instantiation of}}
+  TemplatedStruct<EnumType> s2; // expected-note{{in instantiation of}}
+  return 0;
+}