From 67e8fd0ad22392fdd26011f1cbd4a1566bcf6842 Mon Sep 17 00:00:00 2001 From: Stephan Bergmann Date: Fri, 1 Jul 2016 09:20:00 +0200 Subject: [PATCH 1/2] Resolves: rhbz#1282645 add GCC abi_tag support (cherry picked from commit fd63610295bdb65ea3fd0abd100d6d3ebb7b847e) --- ...ema-part-of-attrbute-abi_tag-support.patch | 395 ++++++ ...ler-part-of-attrbute-abi_tag-support.patch | 1212 +++++++++++++++++ clang.spec | 10 +- 3 files changed, 1616 insertions(+), 1 deletion(-) create mode 100644 0001-GCC-PR23529-Sema-part-of-attrbute-abi_tag-support.patch create mode 100644 0002-GCC-PR23529-Mangler-part-of-attrbute-abi_tag-support.patch diff --git a/0001-GCC-PR23529-Sema-part-of-attrbute-abi_tag-support.patch b/0001-GCC-PR23529-Sema-part-of-attrbute-abi_tag-support.patch new file mode 100644 index 0000000..21c2eb8 --- /dev/null +++ b/0001-GCC-PR23529-Sema-part-of-attrbute-abi_tag-support.patch @@ -0,0 +1,395 @@ +From fcf1bf168329a22bfb1ef32c6d90d2ab9ffea26b Mon Sep 17 00:00:00 2001 +From: Dmitry Polukhin +Date: Wed, 9 Mar 2016 15:30:53 +0000 +Subject: [PATCH 1/2] [GCC] PR23529 Sema part of attrbute abi_tag support +MIME-Version: 1.0 +Content-Type: text/plain; charset=UTF-8 +Content-Transfer-Encoding: 8bit + +Commit: Stephan Bergmann +CommitDate: Fri Jul 1 09:12:17 2016 +0200 + +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. + +Differential Revision: http://reviews.llvm.org/D17567 + +git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@263015 91177308-0d34-0410-b5e6-96231b3b80d8 + +(cherry picked from commit 707118c24cbb8849f27204b27dddfe8213a3dbb5) +Conflicts: + include/clang/Basic/AttrDocs.td + include/clang/Basic/DiagnosticSemaKinds.td + include/clang/Sema/AttributeList.h + lib/Sema/SemaDeclAttr.cpp +plus a4a149223dcbe73632b037fd5694c8589d5ee8d5 "NFC fix documentation build by +rL263015" +plus 2a54cbaf170652dfda762cdbd0ddb004dd1c1d55 "NFC fix documentation build by +rL263015: This time I hope it will fix the build for real." +--- + docs/ItaniumMangleAbiTags.rst | 107 +++++++++++++++++++++++++++++ + docs/index.rst | 1 + + include/clang/Basic/Attr.td | 8 +++ + include/clang/Basic/AttrDocs.td | 13 ++++ + include/clang/Basic/DiagnosticSemaKinds.td | 10 ++- + include/clang/Sema/AttributeList.h | 3 +- + lib/Sema/SemaDecl.cpp | 18 +++++ + lib/Sema/SemaDeclAttr.cpp | 39 +++++++++++ + test/SemaCXX/attr-abi-tag-syntax.cpp | 43 ++++++++++++ + 9 files changed, 240 insertions(+), 2 deletions(-) + create mode 100644 docs/ItaniumMangleAbiTags.rst + create mode 100644 test/SemaCXX/attr-abi-tag-syntax.cpp + +diff --git a/docs/ItaniumMangleAbiTags.rst b/docs/ItaniumMangleAbiTags.rst +new file mode 100644 +index 0000000..2d65031 +--- /dev/null ++++ b/docs/ItaniumMangleAbiTags.rst +@@ -0,0 +1,107 @@ ++======== ++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 are emitted after the ++, before or , and are part of ++the same the is. ++ ++They are mangled as: ++ ++.. code-block:: none ++ ++ ::= * # sort by name ++ ::= B ++ ++Example: ++ ++.. code-block:: c++ ++ ++ __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: ++ ++.. code-block:: none ++ ++ 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: ++ ++.. code-block:: c++ ++ ++ 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 ++(which might include the return type for template functions) are available. ++ ++For s all active tags used in the local part () are available, but not implicit tags which were not active. ++ ++Implicit and explicit tags used in the 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. +diff --git a/docs/index.rst b/docs/index.rst +index a0a70c0..e2dc857 100644 +--- a/docs/index.rst ++++ b/docs/index.rst +@@ -75,6 +75,7 @@ Design Documents + DriverInternals + PTHInternals + PCHInternals ++ ItaniumMangleAbiTags + + + Indices and tables +diff --git a/include/clang/Basic/Attr.td b/include/clang/Basic/Attr.td +index d5ba722..82d5f5f 100644 +--- a/include/clang/Basic/Attr.td ++++ b/include/clang/Basic/Attr.td +@@ -349,6 +349,14 @@ class IgnoredAttr : Attr { + // 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">]; +diff --git a/include/clang/Basic/AttrDocs.td b/include/clang/Basic/AttrDocs.td +index 2567d55..ca82773 100644 +--- a/include/clang/Basic/AttrDocs.td ++++ b/include/clang/Basic/AttrDocs.td +@@ -1859,3 +1859,16 @@ Marking virtual functions as ``disable_tail_calls`` is legal. + + }]; + } ++ ++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. ++ }]; ++} +diff --git a/include/clang/Basic/DiagnosticSemaKinds.td b/include/clang/Basic/DiagnosticSemaKinds.td +index 6ba482c..b77e4bf 100644 +--- a/include/clang/Basic/DiagnosticSemaKinds.td ++++ b/include/clang/Basic/DiagnosticSemaKinds.td +@@ -2434,7 +2434,8 @@ def warn_attribute_wrong_decl_type : Warning< + "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; + def err_attribute_wrong_decl_type : Error; + def warn_type_attribute_wrong_type : Warning< +@@ -4144,6 +4145,13 @@ def err_definition_of_explicitly_defaulted_member : Error< + 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; ++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'">; +diff --git a/include/clang/Sema/AttributeList.h b/include/clang/Sema/AttributeList.h +index e32781d..755ef54 100644 +--- a/include/clang/Sema/AttributeList.h ++++ b/include/clang/Sema/AttributeList.h +@@ -855,7 +855,8 @@ enum AttributeDeclKind { + ExpectedStructOrTypedef, + ExpectedObjectiveCInterfaceOrProtocol, + ExpectedKernelFunction, +- ExpectedFunctionWithProtoType ++ ExpectedFunctionWithProtoType, ++ ExpectedStructClassVariableFunctionOrInlineNamespace + }; + + } // end namespace clang +diff --git a/lib/Sema/SemaDecl.cpp b/lib/Sema/SemaDecl.cpp +index f95d106..681aadc 100644 +--- a/lib/Sema/SemaDecl.cpp ++++ b/lib/Sema/SemaDecl.cpp +@@ -2396,6 +2396,24 @@ void Sema::mergeDeclAttributes(NamedDecl *New, Decl *Old, + } + } + ++ // Re-declaration cannot add abi_tag's. ++ if (const auto *NewAbiTagAttr = New->getAttr()) { ++ if (const auto *OldAbiTagAttr = Old->getAttr()) { ++ 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; + +diff --git a/lib/Sema/SemaDeclAttr.cpp b/lib/Sema/SemaDeclAttr.cpp +index f94c822..7214202 100644 +--- a/lib/Sema/SemaDeclAttr.cpp ++++ b/lib/Sema/SemaDeclAttr.cpp +@@ -4446,6 +4446,42 @@ static void handleDeclspecThreadAttr(Sema &S, Decl *D, + Attr.getRange(), S.Context, Attr.getAttributeSpellingListIndex())); + } + ++static void handleAbiTagAttr(Sema &S, Decl *D, const AttributeList &Attr) { ++ SmallVector 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(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. +@@ -5360,6 +5396,9 @@ static void ProcessDeclAttribute(Sema &S, Scope *scope, Decl *D, + 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: +diff --git a/test/SemaCXX/attr-abi-tag-syntax.cpp b/test/SemaCXX/attr-abi-tag-syntax.cpp +new file mode 100644 +index 0000000..4a4534a +--- /dev/null ++++ b/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}} +-- +2.7.4 + diff --git a/0002-GCC-PR23529-Mangler-part-of-attrbute-abi_tag-support.patch b/0002-GCC-PR23529-Mangler-part-of-attrbute-abi_tag-support.patch new file mode 100644 index 0000000..f333ece --- /dev/null +++ b/0002-GCC-PR23529-Mangler-part-of-attrbute-abi_tag-support.patch @@ -0,0 +1,1212 @@ +From 803b7240b5d08f49126e4a30cc4b0087b500fbd9 Mon Sep 17 00:00:00 2001 +From: Dmitry Polukhin +Date: Thu, 30 Jun 2016 09:40:38 +0000 +Subject: [PATCH 2/2] [GCC] PR23529 Mangler part of attrbute abi_tag support +MIME-Version: 1.0 +Content-Type: text/plain; charset=UTF-8 +Content-Transfer-Encoding: 8bit + +Commit: Stephan Bergmann +CommitDate: Fri Jul 1 09:08:49 2016 +0200 + +Original patch by Stefan Bühler http://reviews.llvm.org/D12834 + +Difference between original and this one: +- fixed all failing tests +- fixed mangling for global variable outside namespace +- emit ABI tags for guards and local names +- clang-format + other stylistic changes +- significantly reworked patch according to Richard's suggestions + +Sema part, committed before http://reviews.llvm.org/D17567 + +Differential revision: http://reviews.llvm.org/D18035 + +git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@274222 91177308-0d34-0410-b5e6-96231b3b80d8 + +(cherry picked from commit 1b7c219dcc9023d058de2a84b4b60b442bf6cbf5) +Conflicts: + lib/AST/ItaniumMangle.cpp + test/PCH/attrs.c +--- + lib/AST/ItaniumMangle.cpp | 488 +++++++++++++++++++++++++++++------ + lib/Sema/SemaDeclAttr.cpp | 4 - + test/CodeGenCXX/mangle-abi-tag.cpp | 204 +++++++++++++++ + test/SemaCXX/attr-abi-tag-syntax.cpp | 10 - + 4 files changed, 611 insertions(+), 95 deletions(-) + create mode 100644 test/CodeGenCXX/mangle-abi-tag.cpp + +diff --git a/lib/AST/ItaniumMangle.cpp b/lib/AST/ItaniumMangle.cpp +index 3f6b682..efcd598 100644 +--- a/lib/AST/ItaniumMangle.cpp ++++ b/lib/AST/ItaniumMangle.cpp +@@ -212,6 +212,12 @@ public: + class CXXNameMangler { + ItaniumMangleContextImpl &Context; + raw_ostream &Out; ++ bool NullOut = false; ++ /// In the "DisableDerivedAbiTags" mode derived ABI tags are not calculated. ++ /// This mode is used when mangler creates another mangler recursively to ++ /// calculate ABI tags for the function return value or the variable type. ++ /// Also it is required to avoid infinite recursion in some cases. ++ bool DisableDerivedAbiTags = false; + + /// The "structor" is the top-level declaration being mangled, if + /// that's not a template specialization; otherwise it's the pattern +@@ -261,15 +267,126 @@ class CXXNameMangler { + + } FunctionTypeDepth; + ++ // abi_tag is a gcc attribute, taking one or more strings called "tags". ++ // The goal is to annotate against which version of a library an object was ++ // built and to be able to provide backwards compatibility ("dual abi"). ++ // For more information see docs/ItaniumMangleAbiTags.rst. ++ typedef SmallVector AbiTagList; ++ ++ // State to gather all implicit and explicit tags used in a mangled name. ++ // Must always have an instance of this while emitting any name to keep ++ // track. ++ class AbiTagState final { ++ public: ++ explicit AbiTagState(AbiTagState *&Head) : LinkHead(Head) { ++ Parent = LinkHead; ++ LinkHead = this; ++ } ++ ++ // No copy, no move. ++ AbiTagState(const AbiTagState &) = delete; ++ AbiTagState &operator=(const AbiTagState &) = delete; ++ ++ ~AbiTagState() { pop(); } ++ ++ void write(raw_ostream &Out, const NamedDecl *ND, ++ const AbiTagList *AdditionalAbiTags) { ++ ND = cast(ND->getCanonicalDecl()); ++ if (!isa(ND) && !isa(ND)) { ++ assert( ++ !AdditionalAbiTags && ++ "only function and variables need a list of additional abi tags"); ++ if (const auto *NS = dyn_cast(ND)) { ++ if (const auto *AbiTag = NS->getAttr()) { ++ UsedAbiTags.insert(UsedAbiTags.end(), AbiTag->tags().begin(), ++ AbiTag->tags().end()); ++ } ++ // Don't emit abi tags for namespaces. ++ return; ++ } ++ } ++ ++ AbiTagList TagList; ++ if (const auto *AbiTag = ND->getAttr()) { ++ UsedAbiTags.insert(UsedAbiTags.end(), AbiTag->tags().begin(), ++ AbiTag->tags().end()); ++ TagList.insert(TagList.end(), AbiTag->tags().begin(), ++ AbiTag->tags().end()); ++ } ++ ++ if (AdditionalAbiTags) { ++ UsedAbiTags.insert(UsedAbiTags.end(), AdditionalAbiTags->begin(), ++ AdditionalAbiTags->end()); ++ TagList.insert(TagList.end(), AdditionalAbiTags->begin(), ++ AdditionalAbiTags->end()); ++ } ++ ++ std::sort(TagList.begin(), TagList.end()); ++ TagList.erase(std::unique(TagList.begin(), TagList.end()), TagList.end()); ++ ++ writeSortedUniqueAbiTags(Out, TagList); ++ } ++ ++ const AbiTagList &getUsedAbiTags() const { return UsedAbiTags; } ++ void setUsedAbiTags(const AbiTagList &AbiTags) { ++ UsedAbiTags = AbiTags; ++ } ++ ++ const AbiTagList &getEmittedAbiTags() const { ++ return EmittedAbiTags; ++ } ++ ++ const AbiTagList &getSortedUniqueUsedAbiTags() { ++ std::sort(UsedAbiTags.begin(), UsedAbiTags.end()); ++ UsedAbiTags.erase(std::unique(UsedAbiTags.begin(), UsedAbiTags.end()), ++ UsedAbiTags.end()); ++ return UsedAbiTags; ++ } ++ ++ private: ++ //! All abi tags used implicitly or explicitly. ++ AbiTagList UsedAbiTags; ++ //! All explicit abi tags (i.e. not from namespace). ++ AbiTagList EmittedAbiTags; ++ ++ AbiTagState *&LinkHead; ++ AbiTagState *Parent = nullptr; ++ ++ void pop() { ++ assert(LinkHead == this && ++ "abi tag link head must point to us on destruction"); ++ if (Parent) { ++ Parent->UsedAbiTags.insert(Parent->UsedAbiTags.end(), ++ UsedAbiTags.begin(), UsedAbiTags.end()); ++ Parent->EmittedAbiTags.insert(Parent->EmittedAbiTags.end(), ++ EmittedAbiTags.begin(), ++ EmittedAbiTags.end()); ++ } ++ LinkHead = Parent; ++ } ++ ++ void writeSortedUniqueAbiTags(raw_ostream &Out, const AbiTagList &AbiTags) { ++ for (const auto &Tag : AbiTags) { ++ EmittedAbiTags.push_back(Tag); ++ Out << "B"; ++ Out << Tag.size(); ++ Out << Tag; ++ } ++ } ++ }; ++ ++ AbiTagState *AbiTags = nullptr; ++ AbiTagState AbiTagsRoot; ++ + llvm::DenseMap Substitutions; + + ASTContext &getASTContext() const { return Context.getASTContext(); } + + public: + CXXNameMangler(ItaniumMangleContextImpl &C, raw_ostream &Out_, +- const NamedDecl *D = nullptr) +- : Context(C), Out(Out_), Structor(getStructor(D)), StructorType(0), +- SeqID(0) { ++ const NamedDecl *D = nullptr, bool NullOut_ = false) ++ : Context(C), Out(Out_), NullOut(NullOut_), Structor(getStructor(D)), ++ StructorType(0), SeqID(0), AbiTagsRoot(AbiTags) { + // These can't be mangled without a ctor type or dtor type. + assert(!D || (!isa(D) && + !isa(D))); +@@ -277,11 +394,21 @@ public: + CXXNameMangler(ItaniumMangleContextImpl &C, raw_ostream &Out_, + const CXXConstructorDecl *D, CXXCtorType Type) + : Context(C), Out(Out_), Structor(getStructor(D)), StructorType(Type), +- SeqID(0) { } ++ SeqID(0), AbiTagsRoot(AbiTags) { } + CXXNameMangler(ItaniumMangleContextImpl &C, raw_ostream &Out_, + const CXXDestructorDecl *D, CXXDtorType Type) + : Context(C), Out(Out_), Structor(getStructor(D)), StructorType(Type), +- SeqID(0) { } ++ SeqID(0), AbiTagsRoot(AbiTags) { } ++ ++ CXXNameMangler(CXXNameMangler &Outer, raw_ostream &Out_) ++ : Context(Outer.Context), Out(Out_), NullOut(false), ++ Structor(Outer.Structor), StructorType(Outer.StructorType), ++ SeqID(Outer.SeqID), AbiTagsRoot(AbiTags) {} ++ ++ CXXNameMangler(CXXNameMangler &Outer, llvm::raw_null_ostream &Out_) ++ : Context(Outer.Context), Out(Out_), NullOut(true), ++ Structor(Outer.Structor), StructorType(Outer.StructorType), ++ SeqID(Outer.SeqID), AbiTagsRoot(AbiTags) {} + + #if MANGLE_CHECKER + ~CXXNameMangler() { +@@ -296,6 +423,9 @@ public: + #endif + raw_ostream &getStream() { return Out; } + ++ void disableDerivedAbiTags() { DisableDerivedAbiTags = true; } ++ static bool shouldHaveAbiTags(ItaniumMangleContextImpl &C, const VarDecl *VD); ++ + void mangle(const NamedDecl *D); + void mangleCallOffset(int64_t NonVirtual, int64_t Virtual); + void mangleNumber(const llvm::APSInt &I); +@@ -334,23 +464,37 @@ private: + DeclarationName name, + unsigned KnownArity = UnknownArity); + +- void mangleName(const TemplateDecl *TD, +- const TemplateArgument *TemplateArgs, +- unsigned NumTemplateArgs); +- void mangleUnqualifiedName(const NamedDecl *ND) { +- mangleUnqualifiedName(ND, ND->getDeclName(), UnknownArity); ++ void mangleFunctionEncodingBareType(const FunctionDecl *FD); ++ ++ void mangleNameWithAbiTags(const NamedDecl *ND, ++ const AbiTagList *AdditionalAbiTags); ++ void mangleTemplateName(const TemplateDecl *TD, ++ const TemplateArgument *TemplateArgs, ++ unsigned NumTemplateArgs); ++ void mangleUnqualifiedName(const NamedDecl *ND, ++ const AbiTagList *AdditionalAbiTags) { ++ mangleUnqualifiedName(ND, ND->getDeclName(), UnknownArity, ++ AdditionalAbiTags); + } + void mangleUnqualifiedName(const NamedDecl *ND, DeclarationName Name, +- unsigned KnownArity); +- void mangleUnscopedName(const NamedDecl *ND); +- void mangleUnscopedTemplateName(const TemplateDecl *ND); +- void mangleUnscopedTemplateName(TemplateName); ++ unsigned KnownArity, ++ const AbiTagList *AdditionalAbiTags); ++ void mangleUnscopedName(const NamedDecl *ND, ++ const AbiTagList *AdditionalAbiTags); ++ void mangleUnscopedTemplateName(const TemplateDecl *ND, ++ const AbiTagList *AdditionalAbiTags); ++ void mangleUnscopedTemplateName(TemplateName, ++ const AbiTagList *AdditionalAbiTags); + void mangleSourceName(const IdentifierInfo *II); +- void mangleLocalName(const Decl *D); ++ void mangleSourceNameWithAbiTags( ++ const NamedDecl *ND, const AbiTagList *AdditionalAbiTags = nullptr); ++ void mangleLocalName(const Decl *D, ++ const AbiTagList *AdditionalAbiTags); + void mangleBlockForPrefix(const BlockDecl *Block); + void mangleUnqualifiedBlock(const BlockDecl *Block); + void mangleLambda(const CXXRecordDecl *Lambda); + void mangleNestedName(const NamedDecl *ND, const DeclContext *DC, ++ const AbiTagList *AdditionalAbiTags, + bool NoFunction=false); + void mangleNestedName(const TemplateDecl *TD, + const TemplateArgument *TemplateArgs, +@@ -405,6 +549,14 @@ private: + void mangleTemplateParameter(unsigned Index); + + void mangleFunctionParam(const ParmVarDecl *parm); ++ ++ void writeAbiTags(const NamedDecl *ND, ++ const AbiTagList *AdditionalAbiTags); ++ ++ // Returns sorted unique list of ABI tags. ++ AbiTagList makeFunctionReturnTypeTags(const FunctionDecl *FD); ++ // Returns sorted unique list of ABI tags. ++ AbiTagList makeVariableTypeTags(const VarDecl *VD); + }; + + } +@@ -448,6 +600,7 @@ bool ItaniumMangleContextImpl::shouldMangleCXXName(const NamedDecl *D) { + while (!DC->isNamespace() && !DC->isTranslationUnit()) + DC = getEffectiveParentContext(DC); + if (DC->isTranslationUnit() && D->getFormalLinkage() != InternalLinkage && ++ !CXXNameMangler::shouldHaveAbiTags(*this, VD) && + !isa(D)) + return false; + } +@@ -455,6 +608,18 @@ bool ItaniumMangleContextImpl::shouldMangleCXXName(const NamedDecl *D) { + return true; + } + ++void CXXNameMangler::writeAbiTags(const NamedDecl *ND, ++ const AbiTagList *AdditionalAbiTags) { ++ assert(AbiTags && "require AbiTagState"); ++ AbiTags->write(Out, ND, DisableDerivedAbiTags ? nullptr : AdditionalAbiTags); ++} ++ ++void CXXNameMangler::mangleSourceNameWithAbiTags( ++ const NamedDecl *ND, const AbiTagList *AdditionalAbiTags) { ++ mangleSourceName(ND->getIdentifier()); ++ writeAbiTags(ND, AdditionalAbiTags); ++} ++ + void CXXNameMangler::mangle(const NamedDecl *D) { + // ::= _Z + // ::= +@@ -472,12 +637,52 @@ void CXXNameMangler::mangle(const NamedDecl *D) { + + void CXXNameMangler::mangleFunctionEncoding(const FunctionDecl *FD) { + // ::= +- mangleName(FD); + + // Don't mangle in the type if this isn't a decl we should typically mangle. +- if (!Context.shouldMangleDeclName(FD)) ++ if (!Context.shouldMangleDeclName(FD)) { ++ mangleName(FD); + return; ++ } + ++ AbiTagList ReturnTypeAbiTags = makeFunctionReturnTypeTags(FD); ++ if (ReturnTypeAbiTags.empty()) { ++ // There are no tags for return type, the simplest case. ++ mangleName(FD); ++ mangleFunctionEncodingBareType(FD); ++ return; ++ } ++ ++ // Mangle function name and encoding to temporary buffer. ++ // We have to output name and encoding to the same mangler to get the same ++ // substitution as it will be in final mangling. ++ SmallString<256> FunctionEncodingBuf; ++ llvm::raw_svector_ostream FunctionEncodingStream(FunctionEncodingBuf); ++ CXXNameMangler FunctionEncodingMangler(*this, FunctionEncodingStream); ++ // Output name of the function. ++ FunctionEncodingMangler.disableDerivedAbiTags(); ++ FunctionEncodingMangler.mangleNameWithAbiTags(FD, nullptr); ++ ++ // Remember length of the function name in the buffer. ++ size_t EncodingPositionStart = FunctionEncodingStream.str().size(); ++ FunctionEncodingMangler.mangleFunctionEncodingBareType(FD); ++ ++ // Get tags from return type that are not present in function name or ++ // encoding. ++ const AbiTagList &UsedAbiTags = ++ FunctionEncodingMangler.AbiTagsRoot.getSortedUniqueUsedAbiTags(); ++ AbiTagList AdditionalAbiTags(ReturnTypeAbiTags.size()); ++ AdditionalAbiTags.erase( ++ std::set_difference(ReturnTypeAbiTags.begin(), ReturnTypeAbiTags.end(), ++ UsedAbiTags.begin(), UsedAbiTags.end(), ++ AdditionalAbiTags.begin()), ++ AdditionalAbiTags.end()); ++ ++ // Output name with implicit tags and function encoding from temporary buffer. ++ mangleNameWithAbiTags(FD, &AdditionalAbiTags); ++ Out << FunctionEncodingStream.str().substr(EncodingPositionStart); ++} ++ ++void CXXNameMangler::mangleFunctionEncodingBareType(const FunctionDecl *FD) { + if (FD->hasAttr()) { + FunctionTypeDepthState Saved = FunctionTypeDepth.push(); + Out << "Ua9enable_ifI"; +@@ -582,6 +787,40 @@ isTemplate(const NamedDecl *ND, const TemplateArgumentList *&TemplateArgs) { + } + + void CXXNameMangler::mangleName(const NamedDecl *ND) { ++ if (const VarDecl *VD = dyn_cast(ND)) { ++ // Variables should have implicit tags from its type. ++ AbiTagList VariableTypeAbiTags = makeVariableTypeTags(VD); ++ if (VariableTypeAbiTags.empty()) { ++ // Simple case no variable type tags. ++ mangleNameWithAbiTags(VD, nullptr); ++ return; ++ } ++ ++ // Mangle variable name to null stream to collect tags. ++ llvm::raw_null_ostream NullOutStream; ++ CXXNameMangler VariableNameMangler(*this, NullOutStream); ++ VariableNameMangler.disableDerivedAbiTags(); ++ VariableNameMangler.mangleNameWithAbiTags(VD, nullptr); ++ ++ // Get tags from variable type that are not present in its name. ++ const AbiTagList &UsedAbiTags = ++ VariableNameMangler.AbiTagsRoot.getSortedUniqueUsedAbiTags(); ++ AbiTagList AdditionalAbiTags(VariableTypeAbiTags.size()); ++ AdditionalAbiTags.erase( ++ std::set_difference(VariableTypeAbiTags.begin(), ++ VariableTypeAbiTags.end(), UsedAbiTags.begin(), ++ UsedAbiTags.end(), AdditionalAbiTags.begin()), ++ AdditionalAbiTags.end()); ++ ++ // Output name with implicit tags. ++ mangleNameWithAbiTags(VD, &AdditionalAbiTags); ++ } else { ++ mangleNameWithAbiTags(ND, nullptr); ++ } ++} ++ ++void CXXNameMangler::mangleNameWithAbiTags(const NamedDecl *ND, ++ const AbiTagList *AdditionalAbiTags) { + // ::= + // ::= + // ::= +@@ -597,7 +836,7 @@ void CXXNameMangler::mangleName(const NamedDecl *ND) { + while (!DC->isNamespace() && !DC->isTranslationUnit()) + DC = getEffectiveParentContext(DC); + else if (GetLocalClassDecl(ND)) { +- mangleLocalName(ND); ++ mangleLocalName(ND, AdditionalAbiTags); + return; + } + +@@ -607,76 +846,86 @@ void CXXNameMangler::mangleName(const NamedDecl *ND) { + // Check if we have a template. + const TemplateArgumentList *TemplateArgs = nullptr; + if (const TemplateDecl *TD = isTemplate(ND, TemplateArgs)) { +- mangleUnscopedTemplateName(TD); ++ mangleUnscopedTemplateName(TD, AdditionalAbiTags); + mangleTemplateArgs(*TemplateArgs); + return; + } + +- mangleUnscopedName(ND); ++ mangleUnscopedName(ND, AdditionalAbiTags); + return; + } + + if (isLocalContainerContext(DC)) { +- mangleLocalName(ND); ++ mangleLocalName(ND, AdditionalAbiTags); + return; + } + +- mangleNestedName(ND, DC); ++ mangleNestedName(ND, DC, AdditionalAbiTags); + } +-void CXXNameMangler::mangleName(const TemplateDecl *TD, +- const TemplateArgument *TemplateArgs, +- unsigned NumTemplateArgs) { ++ ++void CXXNameMangler::mangleTemplateName(const TemplateDecl *TD, ++ const TemplateArgument *TemplateArgs, ++ unsigned NumTemplateArgs) { + const DeclContext *DC = IgnoreLinkageSpecDecls(getEffectiveDeclContext(TD)); + + if (DC->isTranslationUnit() || isStdNamespace(DC)) { +- mangleUnscopedTemplateName(TD); ++ mangleUnscopedTemplateName(TD, nullptr); + mangleTemplateArgs(TemplateArgs, NumTemplateArgs); + } else { + mangleNestedName(TD, TemplateArgs, NumTemplateArgs); + } + } + +-void CXXNameMangler::mangleUnscopedName(const NamedDecl *ND) { ++void CXXNameMangler::mangleUnscopedName(const NamedDecl *ND, ++ const AbiTagList *AdditionalAbiTags) { + // ::= + // ::= St # ::std:: + + if (isStdNamespace(IgnoreLinkageSpecDecls(getEffectiveDeclContext(ND)))) + Out << "St"; + +- mangleUnqualifiedName(ND); ++ mangleUnqualifiedName(ND, AdditionalAbiTags); + } + +-void CXXNameMangler::mangleUnscopedTemplateName(const TemplateDecl *ND) { ++void CXXNameMangler::mangleUnscopedTemplateName( ++ const TemplateDecl *ND, const AbiTagList *AdditionalAbiTags) { + // ::= + // ::= + if (mangleSubstitution(ND)) + return; + + // ::= +- if (const auto *TTP = dyn_cast(ND)) ++ if (const auto *TTP = dyn_cast(ND)) { ++ assert(!AdditionalAbiTags && ++ "template template param cannot have abi tags"); + mangleTemplateParameter(TTP->getIndex()); +- else +- mangleUnscopedName(ND->getTemplatedDecl()); ++ } else { ++ mangleUnscopedName(ND->getTemplatedDecl(), AdditionalAbiTags); ++ } + + addSubstitution(ND); + } + +-void CXXNameMangler::mangleUnscopedTemplateName(TemplateName Template) { ++void CXXNameMangler::mangleUnscopedTemplateName( ++ TemplateName Template, const AbiTagList *AdditionalAbiTags) { + // ::= + // ::= + if (TemplateDecl *TD = Template.getAsTemplateDecl()) +- return mangleUnscopedTemplateName(TD); ++ return mangleUnscopedTemplateName(TD, AdditionalAbiTags); + + if (mangleSubstitution(Template)) + return; + ++ assert(!AdditionalAbiTags && ++ "dependent template name cannot have abi tags"); ++ + DependentTemplateName *Dependent = Template.getAsDependentTemplateName(); + assert(Dependent && "Not a dependent template name?"); + if (const IdentifierInfo *Id = Dependent->getIdentifier()) + mangleSourceName(Id); + else + mangleOperatorName(Dependent->getOperator(), UnknownArity); +- ++ + addSubstitution(Template); + } + +@@ -834,7 +1083,7 @@ void CXXNameMangler::mangleUnresolvedPrefix(NestedNameSpecifier *qualifier, + /*recursive*/ true); + else + Out << "sr"; +- mangleSourceName(qualifier->getAsNamespace()->getIdentifier()); ++ mangleSourceNameWithAbiTags(qualifier->getAsNamespace()); + break; + case NestedNameSpecifier::NamespaceAlias: + if (qualifier->getPrefix()) +@@ -842,7 +1091,7 @@ void CXXNameMangler::mangleUnresolvedPrefix(NestedNameSpecifier *qualifier, + /*recursive*/ true); + else + Out << "sr"; +- mangleSourceName(qualifier->getAsNamespaceAlias()->getIdentifier()); ++ mangleSourceNameWithAbiTags(qualifier->getAsNamespaceAlias()); + break; + + case NestedNameSpecifier::TypeSpec: +@@ -877,6 +1126,7 @@ void CXXNameMangler::mangleUnresolvedPrefix(NestedNameSpecifier *qualifier, + Out << "sr"; + + mangleSourceName(qualifier->getAsIdentifier()); ++ // An Identifier has no type information, so we can't emit abi tags for it. + break; + } + +@@ -922,7 +1172,8 @@ void CXXNameMangler::mangleUnresolvedName(NestedNameSpecifier *qualifier, + + void CXXNameMangler::mangleUnqualifiedName(const NamedDecl *ND, + DeclarationName Name, +- unsigned KnownArity) { ++ unsigned KnownArity, ++ const AbiTagList *AdditionalAbiTags) { + unsigned Arity = KnownArity; + // ::= + // ::= +@@ -941,6 +1192,7 @@ void CXXNameMangler::mangleUnqualifiedName(const NamedDecl *ND, + Out << 'L'; + + mangleSourceName(II); ++ writeAbiTags(ND, AdditionalAbiTags); + break; + } + +@@ -980,6 +1232,7 @@ void CXXNameMangler::mangleUnqualifiedName(const NamedDecl *ND, + assert(FD->getIdentifier() && "Data member name isn't an identifier!"); + + mangleSourceName(FD->getIdentifier()); ++ // Not emitting abi tags: internal name anyway. + break; + } + +@@ -1000,6 +1253,10 @@ void CXXNameMangler::mangleUnqualifiedName(const NamedDecl *ND, + assert(D->getDeclName().getAsIdentifierInfo() && + "Typedef was not named!"); + mangleSourceName(D->getDeclName().getAsIdentifierInfo()); ++ assert(!AdditionalAbiTags && "Type cannot have additional abi tags"); ++ // Explicit abi tags are still possible; take from underlying type, not ++ // from typedef. ++ writeAbiTags(TD, nullptr); + break; + } + +@@ -1009,6 +1266,8 @@ void CXXNameMangler::mangleUnqualifiedName(const NamedDecl *ND, + // ::= + # Parameter types or 'v' for 'void'. + if (const CXXRecordDecl *Record = dyn_cast(TD)) { + if (Record->isLambda() && Record->getLambdaManglingNumber()) { ++ assert(!AdditionalAbiTags && ++ "Lambda type cannot have additional abi tags"); + mangleLambda(Record); + break; + } +@@ -1020,11 +1279,13 @@ void CXXNameMangler::mangleUnqualifiedName(const NamedDecl *ND, + if (UnnamedMangle > 1) + Out << UnnamedMangle - 2; + Out << '_'; ++ writeAbiTags(TD, AdditionalAbiTags); + break; + } + +- // Get a unique id for the anonymous struct. +- unsigned AnonStructId = Context.getAnonymousStructId(TD); ++ // Get a unique id for the anonymous struct. If it is not a real output ++ // ID doesn't matter so use fake one. ++ unsigned AnonStructId = NullOut ? 0 : Context.getAnonymousStructId(TD); + + // Mangle it as a source name in the form + // [n] $_ +@@ -1052,6 +1313,7 @@ void CXXNameMangler::mangleUnqualifiedName(const NamedDecl *ND, + // Otherwise, use the complete constructor name. This is relevant if a + // class with a constructor is declared within a constructor. + mangleCXXCtorType(Ctor_Complete); ++ writeAbiTags(ND, AdditionalAbiTags); + break; + + case DeclarationName::CXXDestructorName: +@@ -1063,6 +1325,7 @@ void CXXNameMangler::mangleUnqualifiedName(const NamedDecl *ND, + // Otherwise, use the complete destructor name. This is relevant if a + // class with a destructor is declared within a destructor. + mangleCXXDtorType(Dtor_Complete); ++ writeAbiTags(ND, AdditionalAbiTags); + break; + + case DeclarationName::CXXOperatorName: +@@ -1078,6 +1341,7 @@ void CXXNameMangler::mangleUnqualifiedName(const NamedDecl *ND, + case DeclarationName::CXXConversionFunctionName: + case DeclarationName::CXXLiteralOperatorName: + mangleOperatorName(Name, Arity); ++ writeAbiTags(ND, AdditionalAbiTags); + break; + + case DeclarationName::CXXUsingDirective: +@@ -1094,6 +1358,7 @@ void CXXNameMangler::mangleSourceName(const IdentifierInfo *II) { + + void CXXNameMangler::mangleNestedName(const NamedDecl *ND, + const DeclContext *DC, ++ const AbiTagList *AdditionalAbiTags, + bool NoFunction) { + // + // ::= N [] [] E +@@ -1119,7 +1384,7 @@ void CXXNameMangler::mangleNestedName(const NamedDecl *ND, + } + else { + manglePrefix(DC, NoFunction); +- mangleUnqualifiedName(ND); ++ mangleUnqualifiedName(ND, AdditionalAbiTags); + } + + Out << 'E'; +@@ -1137,7 +1402,8 @@ void CXXNameMangler::mangleNestedName(const TemplateDecl *TD, + Out << 'E'; + } + +-void CXXNameMangler::mangleLocalName(const Decl *D) { ++void CXXNameMangler::mangleLocalName(const Decl *D, ++ const AbiTagList *AdditionalAbiTags) { + // := Z E [] + // := Z E s [] + // := Z E d [ ] +@@ -1149,15 +1415,26 @@ void CXXNameMangler::mangleLocalName(const Decl *D) { + + Out << 'Z'; + +- if (const ObjCMethodDecl *MD = dyn_cast(DC)) +- mangleObjCMethodName(MD); +- else if (const BlockDecl *BD = dyn_cast(DC)) +- mangleBlockForPrefix(BD); +- else +- mangleFunctionEncoding(cast(DC)); ++ { ++ AbiTagState LocalAbiTags(AbiTags); ++ ++ if (const ObjCMethodDecl *MD = dyn_cast(DC)) ++ mangleObjCMethodName(MD); ++ else if (const BlockDecl *BD = dyn_cast(DC)) ++ mangleBlockForPrefix(BD); ++ else ++ mangleFunctionEncoding(cast(DC)); ++ ++ // Implicit ABI tags (from namespace) are not available in the following ++ // entity; reset to actually emitted tags, which are available. ++ LocalAbiTags.setUsedAbiTags(LocalAbiTags.getEmittedAbiTags()); ++ } + + Out << 'E'; + ++ // GCC 5.3.0 doesn't emit derived ABI tags for local names but that seems to ++ // be a bug that is fixed in trunk. ++ + if (RD) { + // The parameter number is omitted for the last parameter, 0 for the + // second-to-last parameter, 1 for the third-to-last parameter, etc. The +@@ -1182,13 +1459,15 @@ void CXXNameMangler::mangleLocalName(const Decl *D) { + // Mangle the name relative to the closest enclosing function. + // equality ok because RD derived from ND above + if (D == RD) { +- mangleUnqualifiedName(RD); ++ mangleUnqualifiedName(RD, AdditionalAbiTags); + } else if (const BlockDecl *BD = dyn_cast(D)) { + manglePrefix(getEffectiveDeclContext(BD), true /*NoFunction*/); ++ assert(!AdditionalAbiTags && "Block cannot have additional abi tags"); + mangleUnqualifiedBlock(BD); + } else { + const NamedDecl *ND = cast(D); +- mangleNestedName(ND, getEffectiveDeclContext(ND), true /*NoFunction*/); ++ mangleNestedName(ND, getEffectiveDeclContext(ND), AdditionalAbiTags, ++ true /*NoFunction*/); + } + } else if (const BlockDecl *BD = dyn_cast(D)) { + // Mangle a block in a default parameter; see above explanation for +@@ -1205,9 +1484,10 @@ void CXXNameMangler::mangleLocalName(const Decl *D) { + } + } + ++ assert(!AdditionalAbiTags && "Block cannot have additional abi tags"); + mangleUnqualifiedBlock(BD); + } else { +- mangleUnqualifiedName(cast(D)); ++ mangleUnqualifiedName(cast(D), AdditionalAbiTags); + } + + if (const NamedDecl *ND = dyn_cast(RD ? RD : D)) { +@@ -1223,12 +1503,12 @@ void CXXNameMangler::mangleLocalName(const Decl *D) { + + void CXXNameMangler::mangleBlockForPrefix(const BlockDecl *Block) { + if (GetLocalClassDecl(Block)) { +- mangleLocalName(Block); ++ mangleLocalName(Block, /* AdditionalAbiTags */ nullptr); + return; + } + const DeclContext *DC = getEffectiveDeclContext(Block); + if (isLocalContainerContext(DC)) { +- mangleLocalName(Block); ++ mangleLocalName(Block, /* AdditionalAbiTags */ nullptr); + return; + } + manglePrefix(getEffectiveDeclContext(Block)); +@@ -1239,10 +1519,10 @@ void CXXNameMangler::mangleUnqualifiedBlock(const BlockDecl *Block) { + if (Decl *Context = Block->getBlockManglingContextDecl()) { + if ((isa(Context) || isa(Context)) && + Context->getDeclContext()->isRecord()) { +- if (const IdentifierInfo *Name +- = cast(Context)->getIdentifier()) { +- mangleSourceName(Name); +- Out << 'M'; ++ const auto *ND = cast(Context); ++ if (ND->getIdentifier()) { ++ mangleSourceNameWithAbiTags(ND); ++ Out << 'M'; + } + } + } +@@ -1275,7 +1555,7 @@ void CXXNameMangler::mangleLambda(const CXXRecordDecl *Lambda) { + if (const IdentifierInfo *Name + = cast(Context)->getIdentifier()) { + mangleSourceName(Name); +- Out << 'M'; ++ Out << 'M'; + } + } + } +@@ -1362,7 +1642,7 @@ void CXXNameMangler::manglePrefix(const DeclContext *DC, bool NoFunction) { + mangleTemplateArgs(*TemplateArgs); + } else { + manglePrefix(getEffectiveDeclContext(ND), NoFunction); +- mangleUnqualifiedName(ND); ++ mangleUnqualifiedName(ND, nullptr); + } + + addSubstitution(ND); +@@ -1377,19 +1657,19 @@ void CXXNameMangler::mangleTemplatePrefix(TemplateName Template) { + + if (QualifiedTemplateName *Qualified = Template.getAsQualifiedTemplateName()) + manglePrefix(Qualified->getQualifier()); +- ++ + if (OverloadedTemplateStorage *Overloaded + = Template.getAsOverloadedTemplate()) { + mangleUnqualifiedName(nullptr, (*Overloaded->begin())->getDeclName(), +- UnknownArity); ++ UnknownArity, nullptr); + return; + } +- ++ + DependentTemplateName *Dependent = Template.getAsDependentTemplateName(); + assert(Dependent && "Unknown template name kind?"); + if (NestedNameSpecifier *Qualifier = Dependent->getQualifier()) + manglePrefix(Qualifier); +- mangleUnscopedTemplateName(Template); ++ mangleUnscopedTemplateName(Template, /* AdditionalAbiTags */ nullptr); + } + + void CXXNameMangler::mangleTemplatePrefix(const TemplateDecl *ND, +@@ -1408,7 +1688,7 @@ void CXXNameMangler::mangleTemplatePrefix(const TemplateDecl *ND, + mangleTemplateParameter(TTP->getIndex()); + } else { + manglePrefix(getEffectiveDeclContext(ND), NoFunction); +- mangleUnqualifiedName(ND->getTemplatedDecl()); ++ mangleUnqualifiedName(ND->getTemplatedDecl(), nullptr); + } + + addSubstitution(ND); +@@ -1543,17 +1823,17 @@ bool CXXNameMangler::mangleUnresolvedTypeOrSimpleId(QualType Ty, + return true; + + case Type::Typedef: +- mangleSourceName(cast(Ty)->getDecl()->getIdentifier()); ++ mangleSourceNameWithAbiTags(cast(Ty)->getDecl()); + break; + + case Type::UnresolvedUsing: +- mangleSourceName( +- cast(Ty)->getDecl()->getIdentifier()); ++ mangleSourceNameWithAbiTags( ++ cast(Ty)->getDecl()); + break; + + case Type::Enum: + case Type::Record: +- mangleSourceName(cast(Ty)->getDecl()->getIdentifier()); ++ mangleSourceNameWithAbiTags(cast(Ty)->getDecl()); + break; + + case Type::TemplateSpecialization: { +@@ -1571,7 +1851,7 @@ bool CXXNameMangler::mangleUnresolvedTypeOrSimpleId(QualType Ty, + if (isa(TD)) + goto unresolvedType; + +- mangleSourceName(TD->getIdentifier()); ++ mangleSourceNameWithAbiTags(TD); + break; + } + +@@ -1601,8 +1881,8 @@ bool CXXNameMangler::mangleUnresolvedTypeOrSimpleId(QualType Ty, + } + + case Type::InjectedClassName: +- mangleSourceName( +- cast(Ty)->getDecl()->getIdentifier()); ++ mangleSourceNameWithAbiTags( ++ cast(Ty)->getDecl()); + break; + + case Type::DependentName: +@@ -1653,8 +1933,6 @@ void CXXNameMangler::mangleOperatorName(DeclarationName Name, unsigned Arity) { + } + } + +- +- + void + CXXNameMangler::mangleOperatorName(OverloadedOperatorKind OO, unsigned Arity) { + switch (OO) { +@@ -2070,7 +2348,9 @@ void CXXNameMangler::mangleType(const BuiltinType *T) { + case BuiltinType::Id: + #include "clang/AST/BuiltinTypes.def" + case BuiltinType::Dependent: +- llvm_unreachable("mangling a placeholder type"); ++ if (!NullOut) ++ llvm_unreachable("mangling a placeholder type"); ++ break; + case BuiltinType::ObjCId: + Out << "11objc_object"; + break; +@@ -2546,7 +2826,7 @@ void CXXNameMangler::mangleType(const InjectedClassNameType *T) { + + void CXXNameMangler::mangleType(const TemplateSpecializationType *T) { + if (TemplateDecl *TD = T->getTemplateName().getAsTemplateDecl()) { +- mangleName(TD, T->getArgs(), T->getNumArgs()); ++ mangleTemplateName(TD, T->getArgs(), T->getNumArgs()); + } else { + if (mangleSubstitution(QualType(T, 0))) + return; +@@ -2872,12 +3152,14 @@ recurse: + case Expr::PseudoObjectExprClass: + case Expr::AtomicExprClass: + { +- // As bad as this diagnostic is, it's better than crashing. +- DiagnosticsEngine &Diags = Context.getDiags(); +- unsigned DiagID = Diags.getCustomDiagID(DiagnosticsEngine::Error, +- "cannot yet mangle expression type %0"); +- Diags.Report(E->getExprLoc(), DiagID) +- << E->getStmtClassName() << E->getSourceRange(); ++ if (!NullOut) { ++ // As bad as this diagnostic is, it's better than crashing. ++ DiagnosticsEngine &Diags = Context.getDiags(); ++ unsigned DiagID = Diags.getCustomDiagID(DiagnosticsEngine::Error, ++ "cannot yet mangle expression type %0"); ++ Diags.Report(E->getExprLoc(), DiagID) ++ << E->getStmtClassName() << E->getSourceRange(); ++ } + break; + } + +@@ -4020,6 +4302,48 @@ void CXXNameMangler::addSubstitution(uintptr_t Ptr) { + Substitutions[Ptr] = SeqID++; + } + ++CXXNameMangler::AbiTagList ++CXXNameMangler::makeFunctionReturnTypeTags(const FunctionDecl *FD) { ++ // When derived abi tags are disabled there is no need to make any list. ++ if (DisableDerivedAbiTags) ++ return AbiTagList(); ++ ++ llvm::raw_null_ostream NullOutStream; ++ CXXNameMangler TrackReturnTypeTags(*this, NullOutStream); ++ TrackReturnTypeTags.disableDerivedAbiTags(); ++ ++ const FunctionProtoType *Proto = ++ cast(FD->getType()->getAs()); ++ TrackReturnTypeTags.FunctionTypeDepth.enterResultType(); ++ TrackReturnTypeTags.mangleType(Proto->getReturnType()); ++ TrackReturnTypeTags.FunctionTypeDepth.leaveResultType(); ++ ++ return TrackReturnTypeTags.AbiTagsRoot.getSortedUniqueUsedAbiTags(); ++} ++ ++CXXNameMangler::AbiTagList ++CXXNameMangler::makeVariableTypeTags(const VarDecl *VD) { ++ // When derived abi tags are disabled there is no need to make any list. ++ if (DisableDerivedAbiTags) ++ return AbiTagList(); ++ ++ llvm::raw_null_ostream NullOutStream; ++ CXXNameMangler TrackVariableType(*this, NullOutStream); ++ TrackVariableType.disableDerivedAbiTags(); ++ ++ TrackVariableType.mangleType(VD->getType()); ++ ++ return TrackVariableType.AbiTagsRoot.getSortedUniqueUsedAbiTags(); ++} ++ ++bool CXXNameMangler::shouldHaveAbiTags(ItaniumMangleContextImpl &C, ++ const VarDecl *VD) { ++ llvm::raw_null_ostream NullOutStream; ++ CXXNameMangler TrackAbiTags(C, NullOutStream, nullptr, true); ++ TrackAbiTags.mangle(VD); ++ return TrackAbiTags.AbiTagsRoot.getUsedAbiTags().size(); ++} ++ + // + + /// Mangles the name of the declaration D and emits that name to the given +@@ -4121,6 +4445,8 @@ void ItaniumMangleContextImpl::mangleStaticGuardVariable(const VarDecl *D, + // ::= GV # Guard variable for one-time + // # initialization + CXXNameMangler Mangler(*this, Out); ++ // GCC 5.3.0 doesn't emit derived ABI tags for local names but that seems to ++ // be a bug that is fixed in trunk. + Mangler.getStream() << "_ZGV"; + Mangler.mangleName(D); + } +diff --git a/lib/Sema/SemaDeclAttr.cpp b/lib/Sema/SemaDeclAttr.cpp +index 7214202..82649e0 100644 +--- a/lib/Sema/SemaDeclAttr.cpp ++++ b/lib/Sema/SemaDeclAttr.cpp +@@ -4476,10 +4476,6 @@ static void handleAbiTagAttr(Sema &S, Decl *D, const AttributeList &Attr) { + 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, +diff --git a/test/CodeGenCXX/mangle-abi-tag.cpp b/test/CodeGenCXX/mangle-abi-tag.cpp +new file mode 100644 +index 0000000..45702f0 +--- /dev/null ++++ b/test/CodeGenCXX/mangle-abi-tag.cpp +@@ -0,0 +1,204 @@ ++// RUN: %clang_cc1 %s -emit-llvm -triple %itanium_abi_triple -std=c++11 -o - | FileCheck %s ++// RUN: %clang_cc1 %s -emit-llvm -triple i686-linux-gnu -std=c++11 -o - | FileCheck %s ++// RUN: %clang_cc1 %s -emit-llvm -triple x86_64-linux-gnu -std=c++11 -o - | FileCheck %s ++ ++struct __attribute__((abi_tag("A", "B"))) A { }; ++ ++struct B: A { }; ++ ++template ++ ++struct C { ++}; ++ ++struct D { A* p; }; ++ ++template ++struct __attribute__((abi_tag("C", "D"))) E { ++}; ++ ++struct __attribute__((abi_tag("A", "B"))) F { }; ++ ++A a1; ++// CHECK-DAG: @_Z2a1B1AB1B = ++ ++__attribute__((abi_tag("C", "D"))) ++A a2; ++// CHECK-DAG: @_Z2a2B1AB1BB1CB1D = ++ ++B a3; ++// CHECK-DAG: @a3 = ++ ++C a4; ++// CHECK-DAG: @_Z2a4B1AB1B = ++ ++D a5; ++// CHECK-DAG: @a5 = ++ ++E a6; ++// CHECK-DAG: @_Z2a6B1CB1D = ++ ++E a7; ++// CHECK-DAG: @_Z2a7B1AB1BB1CB1D = ++ ++template<> ++struct E { ++ static float a8; ++}; ++float E::a8; ++// CHECK-DAG: @_ZN1EB1CB1DIfE2a8E = ++ ++template<> ++struct E { ++ static bool a9; ++}; ++bool E::a9; ++// CHECK-DAG: @_ZN1EB1CB1DI1FB1AB1BE2a9E = ++ ++struct __attribute__((abi_tag("A", "B"))) A10 { ++ virtual ~A10() {} ++} a10; ++// vtable ++// CHECK-DAG: @_ZTV3A10B1AB1B = ++// typeinfo ++// CHECK-DAG: @_ZTI3A10B1AB1B = ++ ++struct __attribute__((abi_tag("A"))) B11 { ++ static A10 b; ++}; ++A10 B11::b; ++// B11[abi:A]::b[abi:B] ++// CHECK-DAG: @_ZN3B11B1A1bB1BE = ++ ++__attribute__ ((abi_tag("C", "D"))) ++void* f1() { ++ return 0; ++} ++// CHECK-DAG: define {{.*}} @_Z2f1B1CB1Dv( ++ ++__attribute__ ((abi_tag("C", "D"))) ++A* f2() { ++ return 0; ++} ++// CHECK-DAG: define {{.*}} @_Z2f2B1AB1BB1CB1Dv( ++ ++B* f3() { ++ return 0; ++} ++// CHECK-DAG: define {{.*}} @_Z2f3v( ++ ++C* f4() { ++ return 0; ++} ++// CHECK-DAG: define {{.*}} @_Z2f4B1AB1Bv( ++ ++D* f5() { ++ return 0; ++} ++// CHECK-DAG: define {{.*}} @_Z2f5v( ++ ++E* f6() { ++ return 0; ++} ++// CHECK-DAG: define {{.*}} @_Z2f6B1CB1Dv( ++ ++E* f7() { ++ return 0; ++} ++// CHECK-DAG: define {{.*}} @_Z2f7B1AB1BB1CB1Dv( ++ ++void f8(E*) { ++} ++// CHECK-DAG: define {{.*}} @_Z2f8P1EB1CB1DI1AB1AB1BE( ++ ++inline namespace Names1 __attribute__((__abi_tag__)) { ++ class C1 {}; ++} ++C1 f9() { return C1(); } ++// CHECK-DAG: @_Z2f9B6Names1v( ++ ++inline namespace Names2 __attribute__((__abi_tag__("Tag1", "Tag2"))) { ++ class C2 {}; ++} ++C2 f10() { return C2(); } ++// CHECK-DAG: @_Z3f10B4Tag1B4Tag2v( ++ ++void __attribute__((abi_tag("A"))) f11(A) {} ++// f11[abi:A](A[abi:A][abi:B]) ++// CHECK-DAG: define {{.*}} @_Z3f11B1A1AB1AB1B( ++ ++A f12(A) { return A(); } ++// f12(A[abi:A][abi:B]) ++// CHECK-DAG: define {{.*}} @_Z3f121AB1AB1B( ++ ++inline void f13() { ++ struct L { ++ static E* foo() { ++ static A10 a; ++ return 0; ++ } ++ }; ++ L::foo(); ++} ++void f13_test() { ++ f13(); ++} ++// f13()::L::foo[abi:C][abi:D]() ++// CHECK-DAG: define linkonce_odr %struct.E* @_ZZ3f13vEN1L3fooB1CB1DEv( ++ ++// f13()::L::foo[abi:C][abi:D]()::a[abi:A][abi:B] ++// CHECK-DAG: @_ZZZ3f13vEN1L3fooB1CB1DEvE1aB1AB1B = ++ ++// guard variable for f13()::L::foo[abi:C][abi:D]()::a[abi:A][abi:B] ++// CHECK-DAG: @_ZGVZZ3f13vEN1L3fooB1CB1DEvE1aB1AB1B = ++ ++struct __attribute__((abi_tag("TAG"))) A14 { ++ A14 f14(); ++}; ++A14 A14::f14() { ++ return A14(); ++} ++// A14[abi:TAG]::f14() ++// CHECK-DAG: define void @_ZN3A14B3TAG3f14Ev( ++ ++template ++T f15() { ++ return T(); ++} ++void f15_test() { ++ f15(); ++} ++// A14[abi:TAG] f15() ++// CHECK-DAG: define linkonce_odr void @_Z3f15I3A14B3TAGET_v( ++ ++template ++A14 f16() { ++ return A14(); ++} ++void f16_test() { ++ f16(); ++} ++// A14[abi:TAG] f16() ++// CHECK-DAG: define linkonce_odr void @_Z3f16IiE3A14B3TAGv( ++ ++template ++struct __attribute__((abi_tag("TAG"))) A17 { ++ A17 operator+(const A17& a) { ++ return a; ++ } ++}; ++void f17_test() { ++ A17 a, b; ++ a + b; ++} ++// A17[abi:TAG]::operator+(A17[abi:TAG] const&) ++// CHECK-DAG: define linkonce_odr void @_ZN3A17B3TAGIiEplERKS0_( ++ ++struct A18 { ++ operator A() { return A(); } ++}; ++void f18_test() { ++ A a = A18(); ++} ++// A18::operator A[abi:A][abi:B]() but GCC adds the same tags twice! ++// CHECK-DAG: define linkonce_odr void @_ZN3A18cv1AB1AB1BEv( +diff --git a/test/SemaCXX/attr-abi-tag-syntax.cpp b/test/SemaCXX/attr-abi-tag-syntax.cpp +index 4a4534a..4f14a3c 100644 +--- a/test/SemaCXX/attr-abi-tag-syntax.cpp ++++ b/test/SemaCXX/attr-abi-tag-syntax.cpp +@@ -16,28 +16,18 @@ 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}} +-- +2.7.4 + diff --git a/clang.spec b/clang.spec index f31d4c7..b2ed78c 100644 --- a/clang.spec +++ b/clang.spec @@ -1,6 +1,6 @@ Name: clang Version: 3.8.0 -Release: 1%{?dist} +Release: 2%{?dist} Summary: A C language family front-end for LLVM License: NCSA @@ -9,6 +9,9 @@ Source0: http://llvm.org/releases/%{version}/cfe-%{version}.src.tar.xz Source100: clang-config.h +Patch0: 0001-GCC-PR23529-Sema-part-of-attrbute-abi_tag-support.patch +Patch1: 0002-GCC-PR23529-Mangler-part-of-attrbute-abi_tag-support.patch + BuildRequires: cmake BuildRequires: llvm-devel = %{version} BuildRequires: libxml2-devel @@ -63,6 +66,8 @@ intended to run in tandem with a build of a project or code base. %prep %setup -q -n cfe-%{version}.src +%patch0 -p1 +%patch1 -p1 %build mkdir -p _build cd _build @@ -131,6 +136,9 @@ rm -vf %{buildroot}%{_datadir}/clang/clang-format-diff.py* %{_mandir}/man1/scan-build.1.* %changelog +* Fri Jul 01 2016 Stephan Bergmann - 3.8.0-2 +- Resolves: rhbz#1282645 add GCC abi_tag support + * Thu Mar 10 2016 Dave Airlie 3.8.0-1 - clang 3.8.0 final release From 98065e6418d08ce88094e3f875541869b0a116d3 Mon Sep 17 00:00:00 2001 From: Nathaniel McCallum Date: Mon, 14 Nov 2016 14:35:19 -0500 Subject: [PATCH 2/2] Add Requires: compiler-rt to clang-libs --- clang.spec | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) diff --git a/clang.spec b/clang.spec index b2ed78c..6ec1bf1 100644 --- a/clang.spec +++ b/clang.spec @@ -1,6 +1,6 @@ Name: clang Version: 3.8.0 -Release: 2%{?dist} +Release: 3%{?dist} Summary: A C language family front-end for LLVM License: NCSA @@ -38,6 +38,7 @@ as libraries and designed to be loosely-coupled and extensible. %package libs Summary: Runtime library for clang +Requires: compiler-rt%{?_isa} >= %{version} %description libs Runtime library for clang. @@ -136,6 +137,10 @@ rm -vf %{buildroot}%{_datadir}/clang/clang-format-diff.py* %{_mandir}/man1/scan-build.1.* %changelog +* Mon Nov 14 2016 Nathaniel McCallum - 3.8.0-3 +- Add Requires: compiler-rt to clang-libs. +- Without this, compiling with certain CFLAGS breaks. + * Fri Jul 01 2016 Stephan Bergmann - 3.8.0-2 - Resolves: rhbz#1282645 add GCC abi_tag support