[GCC] PR23529 Sema part of attrbute abi_tag support

[DmitryPolukhin]

Summary

Original patch by Stefan Bühler http://reviews.llvm.org/D12834

Difference between original and this one:

• fixed all comments in original code review
• added more tests, all new diagnostics now covered by tests
• moved abi_tag on re-declaration checks to Sema::mergeDeclAttributes where they actually may work as designed
• clang-format + other stylistic changes

Mangle part will be sent for review as a separate patch.

[DmitryPolukhin]

Aaron, friendly ping, please take a look!

[aaron.ballman]

I'll definitely take a look as I have the chance. In WG21 meetings all
week, so it may likely be sometime next week.

~Aaron

[sberg]

lib/Sema/SemaDeclAttr.cpp

4497

needs to be SmallVector<StringRef, 4> with current trunk

[DmitryPolukhin]

Rebase

[aaron.ballman]

docs/ItaniumMangleAbiTags.rst

3

ABI tags (since it's an acronym). Elsewhere as well.

31

an <unqualified-name>

50

A namespace does not have any active tags.

51

Comma after "enum)".

53

Comma after "functions".

69

Code examples for these might be useful for the reader.

80

Separate into two sentences instead of using a semicolon.

"Also, for functions, all tags from the..."

84

Replace the ! with a .

Also, an example might be useful for the reader.

90

as an active tag.

include/clang/Basic/AttrDocs.td

1938

to modify the mangled name

1939

the ability to distinguish between different versions

1940

versions supported.

a newer version of a class could have a different set of data members

1941

a different size.

Comma after attribute.

1942

names

1943

Therefore, (note the comma)

the old mangled name

will use the new

include/clang/Basic/DiagnosticSemaKinds.td

2465

Comma after functions.

4179

in a redeclaration

[DmitryPolukhin]

• fixed comments
• rebase with resolving conflicts

[DmitryPolukhin]

Thank you for the comments!

docs/ItaniumMangleAbiTags.rst

84

I'm 100% sure what exactly Stefan meant here and what is intended GCC behavior vs observed behavior, for example:

namespace A {

inline namespace B __attribute__((abi_tag)) {
   struct C { int x; };
}

}

std::string foo() {

struct E {
   __attribute__((abi_tag("X")))
  static A::C bar() {
    // mangle as _ZZ3fooB5cxx11vEN1E3barB1XEv
    // i.e. foo[abi:cxx11]()::E::bar[abi:X]()
    // abi_tag 'B' is missing for bar in GCC 5.3.0
    return A::C();
  }
};
E::bar();

}

Perhaps we should skip this part.

[aaron.ballman]

LGTM, thank you!

docs/ItaniumMangleAbiTags.rst

+========
+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 a <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 has never 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.
+
+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; for functions also 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 active tag, as it is
+required from the return type `std::string` but not available.

include/clang/Basic/Attr.td

class IgnoredAttr : Attr {
   let SemaHandler = 0;
   let Documentation = [Undocumented];
 }
 
 //
 // 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">];
   let Documentation = [Undocumented];
 }
 
 def Alias : Attr {
   let Spellings = [GCC<"alias">];

include/clang/Basic/AttrDocs.td

2. exception handler:
 
   and compiler pops 'ERROR_CODE' off stack before the 'IRET' instruction.
 
   The exception handler should only be used for exceptions which push an
   error code and all other exceptions must use the interrupt handler.
   The system will crash if the wrong handler is used.
   }];
 }
+
+def AbiTagsDocs : Documentation {
+  let Content = [{
+The ``abi_tag`` attribute can be applied to a function, variable, class or
+inline namespace declaration to modify mangled name of the entity. It allows
+to distinguish different versions of the same entity but with different ABI
+version supported. For example, newer version of a class could have more or less
+data members and thus have different size. Using the ``abi_tag`` attribute it is
+possible to have different mangled name for a global variable of the class type.
+Therefor old code could keep using old manged name and new code will use new
+mangled name with tags.
+  }];
+}

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, enums, fields and typedefs}1">,
+  "variables, enums, fields and typedefs|"
+  "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<
   "'%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_definition_of_implicitly_declared_member : Error<
   "operator|destructor|function}1">;
 def err_definition_of_explicitly_defaulted_member : Error<
   "definition of explicitly defaulted %select{default constructor|copy "
   "constructor|move constructor|copy assignment operator|move assignment "
   "operator|destructor}0">;
 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 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'">;
 def note_deleted_special_member_class_subobject : Note<
   "%select{default constructor|copy constructor|move constructor|"
   "copy assignment operator|move assignment operator|destructor}0 of "
   "%1 is implicitly deleted because "
   "%select{base class %3|%select{||||variant }4field %3}2 has "

include/clang/Sema/AttributeList.h

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

lib/Sema/SemaDecl.cpp

if (AsmLabelAttr *NewA = New->getAttr<AsmLabelAttr>()) {
     } else if (Old->isUsed()) {
       // This redeclaration adds an __asm__ label to a declaration that has
       // already been ODR-used.
       Diag(New->getLocation(), diag::err_late_asm_label_name)
         << isa<FunctionDecl>(Old) << New->getAttr<AsmLabelAttr>()->getRange();
     }
   }
 
+  // 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;
 
   bool foundAny = New->hasAttrs();
 
   // Ensure that any moving of objects within the allocated map is done before
   // we process them.
   if (!foundAny) New->setAttrs(AttrVec());

lib/Sema/SemaDeclAttr.cpp

static void handleDeclspecThreadAttr(Sema &S, Decl *D,
   if (VD->hasLocalStorage()) {
     S.Diag(Attr.getLoc(), diag::err_thread_non_global) << "__declspec(thread)";
     return;
   }
   VD->addAttr(::new (S.Context) ThreadAttr(
       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.
   if (Attr.getNumArgs() > 1) {
     S.Diag(Attr.getLoc(), diag::err_attribute_too_many_arguments)
       << Attr.getName() << 1;
     return;
   }
case AttributeList::AT_MSInheritance:
     handleMSInheritanceAttr(S, D, Attr);
     break;
   case AttributeList::AT_SelectAny:
     handleSimpleAttribute<SelectAnyAttr>(S, D, Attr);
     break;
   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:
     handleAssertExclusiveLockAttr(S, D, Attr);
     break;
   case AttributeList::AT_AssertSharedLock:
     handleAssertSharedLockAttr(S, D, Attr);
     break;

test/SemaCXX/attr-abi-tag-syntax.cpp

+// 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 redeclaration}}
+// FIXME: remove this warning as soon as attribute fully supported.
+// expected-warning@-3 {{'abi_tag' attribute ignored}}