llvm/patches/llvm-3.8.0-D17567-PR23529-Sema-part-of-attrbute-abi_tag-support.patch

Index: cfe/trunk/docs/ItaniumMangleAbiTags.rst
===================================================================
--- cfe/trunk/docs/ItaniumMangleAbiTags.rst
+++ cfe/trunk/docs/ItaniumMangleAbiTags.rst
@@ -0,0 +1,101 @@
+========
+ABI tags
+========
+
+Introduction
+============
+
+This text tries to describe gcc semantic for mangling "abi_tag" attributes
+described in https://gcc.gnu.org/onlinedocs/gcc/C_002b_002b-Attributes.html
+
+There is no guarantee the following rules are correct, complete or make sense
+in any way as they were determined empirically by experiments with gcc5.
+
+Declaration
+===========
+
+ABI tags are declared in an abi_tag attribute and can be applied to a
+function, variable, class or inline namespace declaration. The attribute takes
+one or more strings (called tags); the order does not matter.
+
+See https://gcc.gnu.org/onlinedocs/gcc/C_002b_002b-Attributes.html for
+details.
+
+Tags on an inline namespace are called "implicit tags", all other tags are
+"explicit tags".
+
+Mangling
+========
+
+All tags that are "active" on an <unqualified-name> are emitted after the
+<unqualified-name>, before <template-args> or <discriminator>, and are part of
+the same <substitution> the <unqualified-name> is.
+
+They are mangled as:
+
+    <abi-tags> ::= <abi-tag>*   # sort by name
+    <abi-tag> ::= B <tag source-name>
+
+Example:
+
+    __attribute__((abi_tag("test")))
+    void Func();
+
+    gets mangled as: _Z4FuncB4testv (prettified as `Func[abi:test]()`)
+
+Active tags
+===========
+
+A namespace does not have any active tags. For types (class / struct / union /
+enum), the explicit tags are the active tags.
+
+For variables and functions, the active tags are the explicit tags plus any
+"required tags" which are not in the "available tags" set:
+
+    derived-tags := (required-tags - available-tags)
+    active-tags := explicit-tags + derived-tags
+
+Required tags for a function
+============================
+
+If a function is used as a local scope for another name, and is part of
+another function as local scope, it doesn't have any required tags.
+
+If a function is used as a local scope for a guard variable name, it doesn't
+have any required tags.
+
+Otherwise the function requires any implicit or explicit tag used in the name
+for the return type.
+
+Example:
+    namespace A {
+      inline namespace B __attribute__((abi_tag)) {
+        struct C { int x; };
+      }
+    }
+
+    A::C foo();
+
+    gets mangled as: _Z3fooB1Bv (prettified as `foo[abi:B]()`)
+
+Required tags for a variable
+============================
+
+A variable requires any implicit or explicit tag used in its type.
+
+Available tags
+==============
+
+All tags used in the prefix and in the template arguments for a name are
+available. Also, for functions, all tags from the <bare-function-type>
+(which might include the return type for template functions) are available.
+
+For <local-name>s all active tags used in the local part (<function-
+encoding>) are available, but not implicit tags which were not active.
+
+Implicit and explicit tags used in the <unqualified-name> for a function (as
+in the type of a cast operator) are NOT available.
+
+Example: a cast operator to std::string (which is
+std::__cxx11::basic_string<...>) will use 'cxx11' as an active tag, as it is
+required from the return type `std::string` but not available.
Index: cfe/trunk/include/clang/Basic/Attr.td
===================================================================
--- cfe/trunk/include/clang/Basic/Attr.td
+++ cfe/trunk/include/clang/Basic/Attr.td
@@ -358,6 +358,14 @@
 // Attributes begin here
 //
 
+def AbiTag : Attr {
+  let Spellings = [GCC<"abi_tag">];
+  let Args = [VariadicStringArgument<"Tags">];
+  let Subjects = SubjectList<[Struct, Var, Function, Namespace], ErrorDiag,
+      "ExpectedStructClassVariableFunctionOrInlineNamespace">;
+  let Documentation = [AbiTagsDocs];
+}
+
 def AddressSpace : TypeAttr {
   let Spellings = [GNU<"address_space">];
   let Args = [IntArgument<"AddressSpace">];
Index: cfe/trunk/include/clang/Basic/AttrDocs.td
===================================================================
--- cfe/trunk/include/clang/Basic/AttrDocs.td
+++ cfe/trunk/include/clang/Basic/AttrDocs.td
@@ -2132,3 +2132,16 @@
 optimizations like C++'s named return value optimization (NRVO).
   }];
 }
+
+def AbiTagsDocs : Documentation {
+  let Content = [{
+The ``abi_tag`` attribute can be applied to a function, variable, class or
+inline namespace declaration to modify the mangled name of the entity. It gives
+the ability to distinguish between different versions of the same entity but
+with different ABI versions supported. For example, a newer version of a class
+could have a different set of data members and thus have a different size. Using
+the ``abi_tag`` attribute, it is possible to have different mangled names for
+a global variable of the class type. Therefor, the old code could keep using
+the old manged name and the new code will use the new mangled name with tags.
+  }];
+}
Index: cfe/trunk/include/clang/Basic/DiagnosticSemaKinds.td
===================================================================
--- cfe/trunk/include/clang/Basic/DiagnosticSemaKinds.td
+++ cfe/trunk/include/clang/Basic/DiagnosticSemaKinds.td
@@ -2477,7 +2477,8 @@
   "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}1">,
+  "interface or protocol declarations|kernel functions|non-K&R-style functions|"
+  "structs, classes, variables, functions, and inline namespaces}1">,
   InGroup<IgnoredAttributes>;
 def err_attribute_wrong_decl_type : Error<warn_attribute_wrong_decl_type.Text>;
 def warn_type_attribute_wrong_type : Warning<
@@ -4195,6 +4196,13 @@
 def err_redefinition_extern_inline : Error<
   "redefinition of a 'extern inline' function %0 is not supported in "
   "%select{C99 mode|C++}1">;
+def warn_attr_abi_tag_namespace : Warning<
+  "'abi_tag' attribute on %select{non-inline|anonymous}0 namespace ignored">,
+  InGroup<IgnoredAttributes>;
+def err_abi_tag_on_redeclaration : Error<
+  "cannot add 'abi_tag' attribute in a redeclaration">;
+def err_new_abi_tag_on_redeclaration : Error<
+  "'abi_tag' %0 missing in original declaration">;
 
 def note_deleted_dtor_no_operator_delete : Note<
   "virtual destructor requires an unambiguous, accessible 'operator delete'">;
Index: cfe/trunk/include/clang/Sema/AttributeList.h
===================================================================
--- cfe/trunk/include/clang/Sema/AttributeList.h
+++ cfe/trunk/include/clang/Sema/AttributeList.h
@@ -895,7 +895,8 @@
   ExpectedStructOrTypedef,
   ExpectedObjectiveCInterfaceOrProtocol,
   ExpectedKernelFunction,
-  ExpectedFunctionWithProtoType
+  ExpectedFunctionWithProtoType,
+  ExpectedStructClassVariableFunctionOrInlineNamespace
 };
 
 }  // end namespace clang
Index: cfe/trunk/lib/Sema/SemaDecl.cpp
===================================================================
--- cfe/trunk/lib/Sema/SemaDecl.cpp
+++ cfe/trunk/lib/Sema/SemaDecl.cpp
@@ -2398,6 +2398,24 @@
     }
   }
 
+  // Re-declaration cannot add abi_tag's.
+  if (const auto *NewAbiTagAttr = New->getAttr<AbiTagAttr>()) {
+    if (const auto *OldAbiTagAttr = Old->getAttr<AbiTagAttr>()) {
+      for (const auto &NewTag : NewAbiTagAttr->tags()) {
+        if (std::find(OldAbiTagAttr->tags_begin(), OldAbiTagAttr->tags_end(),
+                      NewTag) == OldAbiTagAttr->tags_end()) {
+          Diag(NewAbiTagAttr->getLocation(),
+               diag::err_new_abi_tag_on_redeclaration)
+              << NewTag;
+          Diag(OldAbiTagAttr->getLocation(), diag::note_previous_declaration);
+        }
+      }
+    } else {
+      Diag(NewAbiTagAttr->getLocation(), diag::err_abi_tag_on_redeclaration);
+      Diag(Old->getLocation(), diag::note_previous_declaration);
+    }
+  }
+
   if (!Old->hasAttrs())
     return;
 
Index: cfe/trunk/lib/Sema/SemaDeclAttr.cpp
===================================================================
--- cfe/trunk/lib/Sema/SemaDeclAttr.cpp
+++ cfe/trunk/lib/Sema/SemaDeclAttr.cpp
@@ -4615,6 +4615,42 @@
       Attr.getRange(), S.Context, Attr.getAttributeSpellingListIndex()));
 }
 
+static void handleAbiTagAttr(Sema &S, Decl *D, const AttributeList &Attr) {
+  SmallVector<std::string, 4> Tags;
+  for (unsigned I = 0, E = Attr.getNumArgs(); I != E; ++I) {
+    StringRef Tag;
+    if (!S.checkStringLiteralArgumentAttr(Attr, I, Tag))
+      return;
+    Tags.push_back(Tag);
+  }
+
+  if (const auto *NS = dyn_cast<NamespaceDecl>(D)) {
+    if (!NS->isInline()) {
+      S.Diag(Attr.getLoc(), diag::warn_attr_abi_tag_namespace) << 0;
+      return;
+    }
+    if (NS->isAnonymousNamespace()) {
+      S.Diag(Attr.getLoc(), diag::warn_attr_abi_tag_namespace) << 1;
+      return;
+    }
+    if (Attr.getNumArgs() == 0)
+      Tags.push_back(NS->getName());
+  } else if (!checkAttributeAtLeastNumArgs(S, Attr, 1))
+    return;
+
+  // Store tags sorted and without duplicates.
+  std::sort(Tags.begin(), Tags.end());
+  Tags.erase(std::unique(Tags.begin(), Tags.end()), Tags.end());
+
+  D->addAttr(::new (S.Context)
+             AbiTagAttr(Attr.getRange(), S.Context, Tags.data(), Tags.size(),
+                        Attr.getAttributeSpellingListIndex()));
+
+  // FIXME: remove this warning as soon as mangled part is ready.
+  S.Diag(Attr.getRange().getBegin(), diag::warn_attribute_ignored)
+        << Attr.getName();
+}
+
 static void handleARMInterruptAttr(Sema &S, Decl *D,
                                    const AttributeList &Attr) {
   // Check the attribute arguments.
@@ -5637,6 +5673,9 @@
   case AttributeList::AT_Thread:
     handleDeclspecThreadAttr(S, D, Attr);
     break;
+  case AttributeList::AT_AbiTag:
+    handleAbiTagAttr(S, D, Attr);
+    break;
 
   // Thread safety attributes:
   case AttributeList::AT_AssertExclusiveLock:
Index: cfe/trunk/test/SemaCXX/attr-abi-tag-syntax.cpp
===================================================================
--- cfe/trunk/test/SemaCXX/attr-abi-tag-syntax.cpp
+++ cfe/trunk/test/SemaCXX/attr-abi-tag-syntax.cpp
@@ -0,0 +1,43 @@
+// RUN: %clang_cc1 -std=c++11 -fsyntax-only -verify %s
+
+namespace N1 {
+
+namespace __attribute__((__abi_tag__)) {}
+// expected-warning@-1 {{'abi_tag' attribute on non-inline namespace ignored}}
+
+namespace N __attribute__((__abi_tag__)) {}
+// expected-warning@-1 {{'abi_tag' attribute on non-inline namespace ignored}}
+
+} // namespace N1
+
+namespace N2 {
+
+inline namespace __attribute__((__abi_tag__)) {}
+// expected-warning@-1 {{'abi_tag' attribute on anonymous namespace ignored}}
+
+inline namespace N __attribute__((__abi_tag__)) {}
+// FIXME: remove this warning as soon as attribute fully supported.
+// expected-warning@-2 {{'__abi_tag__' attribute ignored}}
+
+} // namespcace N2
+
+__attribute__((abi_tag("B", "A"))) extern int a1;
+// FIXME: remove this warning as soon as attribute fully supported.
+// expected-warning@-2 {{'abi_tag' attribute ignored}}
+
+__attribute__((abi_tag("A", "B"))) extern int a1;
+// expected-note@-1 {{previous declaration is here}}
+// FIXME: remove this warning as soon as attribute fully supported.
+// expected-warning@-3 {{'abi_tag' attribute ignored}}
+
+__attribute__((abi_tag("A", "C"))) extern int a1;
+// expected-error@-1 {{'abi_tag' C missing in original declaration}}
+// FIXME: remove this warning as soon as attribute fully supported.
+// expected-warning@-3 {{'abi_tag' attribute ignored}}
+
+extern int a2;
+// expected-note@-1 {{previous declaration is here}}
+__attribute__((abi_tag("A")))extern int a2;
+// expected-error@-1 {{cannot add 'abi_tag' attribute in a redeclaration}}
+// FIXME: remove this warning as soon as attribute fully supported.
+// expected-warning@-3 {{'abi_tag' attribute ignored}}
1	Index: cfe/trunk/docs/ItaniumMangleAbiTags.rst
2	===================================================================
3	--- cfe/trunk/docs/ItaniumMangleAbiTags.rst
4	+++ cfe/trunk/docs/ItaniumMangleAbiTags.rst
5	@@ -0,0 +1,101 @@
6	+========
7	+ABI tags
8	+========
9	+
10	+Introduction
11	+============
12	+
13	+This text tries to describe gcc semantic for mangling "abi_tag" attributes
14	+described in https://gcc.gnu.org/onlinedocs/gcc/C_002b_002b-Attributes.html
15	+
16	+There is no guarantee the following rules are correct, complete or make sense
17	+in any way as they were determined empirically by experiments with gcc5.
18	+
19	+Declaration
20	+===========
21	+
22	+ABI tags are declared in an abi_tag attribute and can be applied to a
23	+function, variable, class or inline namespace declaration. The attribute takes
24	+one or more strings (called tags); the order does not matter.
25	+
26	+See https://gcc.gnu.org/onlinedocs/gcc/C_002b_002b-Attributes.html for
27	+details.
28	+
29	+Tags on an inline namespace are called "implicit tags", all other tags are
30	+"explicit tags".
31	+
32	+Mangling
33	+========
34	+
35	+All tags that are "active" on an <unqualified-name> are emitted after the
36	+<unqualified-name>, before <template-args> or <discriminator>, and are part of
37	+the same <substitution> the <unqualified-name> is.
38	+
39	+They are mangled as:
40	+
41	+ <abi-tags> ::= <abi-tag>* # sort by name
42	+ <abi-tag> ::= B <tag source-name>
43	+
44	+Example:
45	+
46	+ __attribute__((abi_tag("test")))
47	+ void Func();
48	+
49	+ gets mangled as: _Z4FuncB4testv (prettified as `Func[abi:test]()`)
50	+
51	+Active tags
52	+===========
53	+
54	+A namespace does not have any active tags. For types (class / struct / union /
55	+enum), the explicit tags are the active tags.
56	+
57	+For variables and functions, the active tags are the explicit tags plus any
58	+"required tags" which are not in the "available tags" set:
59	+
60	+ derived-tags := (required-tags - available-tags)
61	+ active-tags := explicit-tags + derived-tags
62	+
63	+Required tags for a function
64	+============================
65	+
66	+If a function is used as a local scope for another name, and is part of
67	+another function as local scope, it doesn't have any required tags.
68	+
69	+If a function is used as a local scope for a guard variable name, it doesn't
70	+have any required tags.
71	+
72	+Otherwise the function requires any implicit or explicit tag used in the name
73	+for the return type.
74	+
75	+Example:
76	+ namespace A {
77	+ inline namespace B __attribute__((abi_tag)) {
78	+ struct C { int x; };
79	+ }
80	+ }
81	+
82	+ A::C foo();
83	+
84	+ gets mangled as: _Z3fooB1Bv (prettified as `foo[abi:B]()`)
85	+
86	+Required tags for a variable
87	+============================
88	+
89	+A variable requires any implicit or explicit tag used in its type.
90	+
91	+Available tags
92	+==============
93	+
94	+All tags used in the prefix and in the template arguments for a name are
95	+available. Also, for functions, all tags from the <bare-function-type>
96	+(which might include the return type for template functions) are available.
97	+
98	+For <local-name>s all active tags used in the local part (<function-
99	+encoding>) are available, but not implicit tags which were not active.
100	+
101	+Implicit and explicit tags used in the <unqualified-name> for a function (as
102	+in the type of a cast operator) are NOT available.
103	+
104	+Example: a cast operator to std::string (which is
105	+std::__cxx11::basic_string<...>) will use 'cxx11' as an active tag, as it is
106	+required from the return type `std::string` but not available.
107	Index: cfe/trunk/include/clang/Basic/Attr.td
108	===================================================================
109	--- cfe/trunk/include/clang/Basic/Attr.td
110	+++ cfe/trunk/include/clang/Basic/Attr.td
111	@@ -358,6 +358,14 @@
112	// Attributes begin here
113	//
114
115	+def AbiTag : Attr {
116	+ let Spellings = [GCC<"abi_tag">];
117	+ let Args = [VariadicStringArgument<"Tags">];
118	+ let Subjects = SubjectList<[Struct, Var, Function, Namespace], ErrorDiag,
119	+ "ExpectedStructClassVariableFunctionOrInlineNamespace">;
120	+ let Documentation = [AbiTagsDocs];
121	+}
122	+
123	def AddressSpace : TypeAttr {
124	let Spellings = [GNU<"address_space">];
125	let Args = [IntArgument<"AddressSpace">];
126	Index: cfe/trunk/include/clang/Basic/AttrDocs.td
127	===================================================================
128	--- cfe/trunk/include/clang/Basic/AttrDocs.td
129	+++ cfe/trunk/include/clang/Basic/AttrDocs.td
130	@@ -2132,3 +2132,16 @@
131	optimizations like C++'s named return value optimization (NRVO).
132	}];
133	}
134	+
135	+def AbiTagsDocs : Documentation {
136	+ let Content = [{
137	+The ``abi_tag`` attribute can be applied to a function, variable, class or
138	+inline namespace declaration to modify the mangled name of the entity. It gives
139	+the ability to distinguish between different versions of the same entity but
140	+with different ABI versions supported. For example, a newer version of a class
141	+could have a different set of data members and thus have a different size. Using
142	+the ``abi_tag`` attribute, it is possible to have different mangled names for
143	+a global variable of the class type. Therefor, the old code could keep using
144	+the old manged name and the new code will use the new mangled name with tags.
145	+ }];
146	+}
147	Index: cfe/trunk/include/clang/Basic/DiagnosticSemaKinds.td
148	===================================================================
149	--- cfe/trunk/include/clang/Basic/DiagnosticSemaKinds.td
150	+++ cfe/trunk/include/clang/Basic/DiagnosticSemaKinds.td
151	@@ -2477,7 +2477,8 @@
152	"Objective-C instance methods\|init methods of interface or class extension declarations\|"
153	"variables, functions and classes\|Objective-C protocols\|"
154	"functions and global variables\|structs, unions, and typedefs\|structs and typedefs\|"
155	- "interface or protocol declarations\|kernel functions\|non-K&R-style functions}1">,
156	+ "interface or protocol declarations\|kernel functions\|non-K&R-style functions\|"
157	+ "structs, classes, variables, functions, and inline namespaces}1">,
158	InGroup<IgnoredAttributes>;
159	def err_attribute_wrong_decl_type : Error<warn_attribute_wrong_decl_type.Text>;
160	def warn_type_attribute_wrong_type : Warning<
161	@@ -4195,6 +4196,13 @@
162	def err_redefinition_extern_inline : Error<
163	"redefinition of a 'extern inline' function %0 is not supported in "
164	"%select{C99 mode\|C++}1">;
165	+def warn_attr_abi_tag_namespace : Warning<
166	+ "'abi_tag' attribute on %select{non-inline\|anonymous}0 namespace ignored">,
167	+ InGroup<IgnoredAttributes>;
168	+def err_abi_tag_on_redeclaration : Error<
169	+ "cannot add 'abi_tag' attribute in a redeclaration">;
170	+def err_new_abi_tag_on_redeclaration : Error<
171	+ "'abi_tag' %0 missing in original declaration">;
172
173	def note_deleted_dtor_no_operator_delete : Note<
174	"virtual destructor requires an unambiguous, accessible 'operator delete'">;
175	Index: cfe/trunk/include/clang/Sema/AttributeList.h
176	===================================================================
177	--- cfe/trunk/include/clang/Sema/AttributeList.h
178	+++ cfe/trunk/include/clang/Sema/AttributeList.h
179	@@ -895,7 +895,8 @@
180	ExpectedStructOrTypedef,
181	ExpectedObjectiveCInterfaceOrProtocol,
182	ExpectedKernelFunction,
183	- ExpectedFunctionWithProtoType
184	+ ExpectedFunctionWithProtoType,
185	+ ExpectedStructClassVariableFunctionOrInlineNamespace
186	};
187
188	} // end namespace clang
189	Index: cfe/trunk/lib/Sema/SemaDecl.cpp
190	===================================================================
191	--- cfe/trunk/lib/Sema/SemaDecl.cpp
192	+++ cfe/trunk/lib/Sema/SemaDecl.cpp
193	@@ -2398,6 +2398,24 @@
194	}
195	}
196
197	+ // Re-declaration cannot add abi_tag's.
198	+ if (const auto *NewAbiTagAttr = New->getAttr<AbiTagAttr>()) {
199	+ if (const auto *OldAbiTagAttr = Old->getAttr<AbiTagAttr>()) {
200	+ for (const auto &NewTag : NewAbiTagAttr->tags()) {
201	+ if (std::find(OldAbiTagAttr->tags_begin(), OldAbiTagAttr->tags_end(),
202	+ NewTag) == OldAbiTagAttr->tags_end()) {
203	+ Diag(NewAbiTagAttr->getLocation(),
204	+ diag::err_new_abi_tag_on_redeclaration)
205	+ << NewTag;
206	+ Diag(OldAbiTagAttr->getLocation(), diag::note_previous_declaration);
207	+ }
208	+ }
209	+ } else {
210	+ Diag(NewAbiTagAttr->getLocation(), diag::err_abi_tag_on_redeclaration);
211	+ Diag(Old->getLocation(), diag::note_previous_declaration);
212	+ }
213	+ }
214	+
215	if (!Old->hasAttrs())
216	return;
217
218	Index: cfe/trunk/lib/Sema/SemaDeclAttr.cpp
219	===================================================================
220	--- cfe/trunk/lib/Sema/SemaDeclAttr.cpp
221	+++ cfe/trunk/lib/Sema/SemaDeclAttr.cpp
222	@@ -4615,6 +4615,42 @@
223	Attr.getRange(), S.Context, Attr.getAttributeSpellingListIndex()));
224	}
225
226	+static void handleAbiTagAttr(Sema &S, Decl *D, const AttributeList &Attr) {
227	+ SmallVector<std::string, 4> Tags;
228	+ for (unsigned I = 0, E = Attr.getNumArgs(); I != E; ++I) {
229	+ StringRef Tag;
230	+ if (!S.checkStringLiteralArgumentAttr(Attr, I, Tag))
231	+ return;
232	+ Tags.push_back(Tag);
233	+ }
234	+
235	+ if (const auto *NS = dyn_cast<NamespaceDecl>(D)) {
236	+ if (!NS->isInline()) {
237	+ S.Diag(Attr.getLoc(), diag::warn_attr_abi_tag_namespace) << 0;
238	+ return;
239	+ }
240	+ if (NS->isAnonymousNamespace()) {
241	+ S.Diag(Attr.getLoc(), diag::warn_attr_abi_tag_namespace) << 1;
242	+ return;
243	+ }
244	+ if (Attr.getNumArgs() == 0)
245	+ Tags.push_back(NS->getName());
246	+ } else if (!checkAttributeAtLeastNumArgs(S, Attr, 1))
247	+ return;
248	+
249	+ // Store tags sorted and without duplicates.
250	+ std::sort(Tags.begin(), Tags.end());
251	+ Tags.erase(std::unique(Tags.begin(), Tags.end()), Tags.end());
252	+
253	+ D->addAttr(::new (S.Context)
254	+ AbiTagAttr(Attr.getRange(), S.Context, Tags.data(), Tags.size(),
255	+ Attr.getAttributeSpellingListIndex()));
256	+
257	+ // FIXME: remove this warning as soon as mangled part is ready.
258	+ S.Diag(Attr.getRange().getBegin(), diag::warn_attribute_ignored)
259	+ << Attr.getName();
260	+}
261	+
262	static void handleARMInterruptAttr(Sema &S, Decl *D,
263	const AttributeList &Attr) {
264	// Check the attribute arguments.
265	@@ -5637,6 +5673,9 @@
266	case AttributeList::AT_Thread:
267	handleDeclspecThreadAttr(S, D, Attr);
268	break;
269	+ case AttributeList::AT_AbiTag:
270	+ handleAbiTagAttr(S, D, Attr);
271	+ break;
272
273	// Thread safety attributes:
274	case AttributeList::AT_AssertExclusiveLock:
275	Index: cfe/trunk/test/SemaCXX/attr-abi-tag-syntax.cpp
276	===================================================================
277	--- cfe/trunk/test/SemaCXX/attr-abi-tag-syntax.cpp
278	+++ cfe/trunk/test/SemaCXX/attr-abi-tag-syntax.cpp
279	@@ -0,0 +1,43 @@
280	+// RUN: %clang_cc1 -std=c++11 -fsyntax-only -verify %s
281	+
282	+namespace N1 {
283	+
284	+namespace __attribute__((__abi_tag__)) {}
285	+// expected-warning@-1 {{'abi_tag' attribute on non-inline namespace ignored}}
286	+
287	+namespace N __attribute__((__abi_tag__)) {}
288	+// expected-warning@-1 {{'abi_tag' attribute on non-inline namespace ignored}}
289	+
290	+} // namespace N1
291	+
292	+namespace N2 {
293	+
294	+inline namespace __attribute__((__abi_tag__)) {}
295	+// expected-warning@-1 {{'abi_tag' attribute on anonymous namespace ignored}}
296	+
297	+inline namespace N __attribute__((__abi_tag__)) {}
298	+// FIXME: remove this warning as soon as attribute fully supported.
299	+// expected-warning@-2 {{'__abi_tag__' attribute ignored}}
300	+
301	+} // namespcace N2
302	+
303	+__attribute__((abi_tag("B", "A"))) extern int a1;
304	+// FIXME: remove this warning as soon as attribute fully supported.
305	+// expected-warning@-2 {{'abi_tag' attribute ignored}}
306	+
307	+__attribute__((abi_tag("A", "B"))) extern int a1;
308	+// expected-note@-1 {{previous declaration is here}}
309	+// FIXME: remove this warning as soon as attribute fully supported.
310	+// expected-warning@-3 {{'abi_tag' attribute ignored}}
311	+
312	+__attribute__((abi_tag("A", "C"))) extern int a1;
313	+// expected-error@-1 {{'abi_tag' C missing in original declaration}}
314	+// FIXME: remove this warning as soon as attribute fully supported.
315	+// expected-warning@-3 {{'abi_tag' attribute ignored}}
316	+
317	+extern int a2;
318	+// expected-note@-1 {{previous declaration is here}}
319	+__attribute__((abi_tag("A")))extern int a2;
320	+// expected-error@-1 {{cannot add 'abi_tag' attribute in a redeclaration}}
321	+// FIXME: remove this warning as soon as attribute fully supported.
322	+// expected-warning@-3 {{'abi_tag' attribute ignored}}