From 803b7240b5d08f49126e4a30cc4b0087b500fbd9 Mon Sep 17 00:00:00 2001

From: Dmitry Polukhin <dmitry.polukhin@gmail.com>

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 <sbergman@redhat.com>

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<StringRef, 4> 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<NamedDecl>(ND->getCanonicalDecl());

+      if (!isa<FunctionDecl>(ND) && !isa<VarDecl>(ND)) {

+        assert(

+            !AdditionalAbiTags &&

+            "only function and variables need a list of additional abi tags");

+        if (const auto *NS = dyn_cast<NamespaceDecl>(ND)) {

+          if (const auto *AbiTag = NS->getAttr<AbiTagAttr>()) {

+            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<AbiTagAttr>()) {

+        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<uintptr_t, unsigned> 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<CXXDestructorDecl>(D) &&

                   !isa<CXXConstructorDecl>(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<VarTemplateSpecializationDecl>(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) {

   // <mangled-name> ::= _Z <encoding>

   //            ::= <data name>

@@ -472,12 +637,52 @@ void CXXNameMangler::mangle(const NamedDecl *D) {

 void CXXNameMangler::mangleFunctionEncoding(const FunctionDecl *FD) {

   // <encoding> ::= <function name> <bare-function-type>

-  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<EnableIfAttr>()) {

     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<VarDecl>(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) {

   //  <name> ::= <nested-name>

   //         ::= <unscoped-name>

   //         ::= <unscoped-template-name> <template-args>

@@ -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) {

   //  <unscoped-name> ::= <unqualified-name>

   //                  ::= St <unqualified-name>   # ::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) {

   //     <unscoped-template-name> ::= <unscoped-name>

   //                              ::= <substitution>

   if (mangleSubstitution(ND))

     return;

   // <template-template-param> ::= <template-param>

-  if (const auto *TTP = dyn_cast<TemplateTemplateParmDecl>(ND))

+  if (const auto *TTP = dyn_cast<TemplateTemplateParmDecl>(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) {

   //     <unscoped-template-name> ::= <unscoped-name>

   //                              ::= <substitution>

   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;

   //  <unqualified-name> ::= <operator-name>

   //                     ::= <ctor-dtor-name>

@@ -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,

     // <lambda-sig> ::= <parameter-type>+   # Parameter types or 'v' for 'void'.

     if (const CXXRecordDecl *Record = dyn_cast<CXXRecordDecl>(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] $_<id>

@@ -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) {

   // <nested-name> 

   //   ::= N [<CV-qualifiers>] [<ref-qualifier>] <prefix> <unqualified-name> 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) {

   // <local-name> := Z <function encoding> E <entity name> [<discriminator>]

   //              := Z <function encoding> E s [<discriminator>]

   // <local-name> := Z <function encoding> E d [ <parameter number> ] 

@@ -1149,15 +1415,26 @@ void CXXNameMangler::mangleLocalName(const Decl *D) {

   Out << 'Z';

-  if (const ObjCMethodDecl *MD = dyn_cast<ObjCMethodDecl>(DC))

-    mangleObjCMethodName(MD);

-  else if (const BlockDecl *BD = dyn_cast<BlockDecl>(DC))

-    mangleBlockForPrefix(BD);

-  else

-    mangleFunctionEncoding(cast<FunctionDecl>(DC));

+  {

+    AbiTagState LocalAbiTags(AbiTags);

+

+    if (const ObjCMethodDecl *MD = dyn_cast<ObjCMethodDecl>(DC))

+      mangleObjCMethodName(MD);

+    else if (const BlockDecl *BD = dyn_cast<BlockDecl>(DC))

+      mangleBlockForPrefix(BD);

+    else

+      mangleFunctionEncoding(cast<FunctionDecl>(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<BlockDecl>(D)) {

       manglePrefix(getEffectiveDeclContext(BD), true /*NoFunction*/);

+      assert(!AdditionalAbiTags && "Block cannot have additional abi tags");

       mangleUnqualifiedBlock(BD);

     } else {

       const NamedDecl *ND = cast<NamedDecl>(D);

-      mangleNestedName(ND, getEffectiveDeclContext(ND), true /*NoFunction*/);

+      mangleNestedName(ND, getEffectiveDeclContext(ND), AdditionalAbiTags,

+                       true /*NoFunction*/);

     }

   } else if (const BlockDecl *BD = dyn_cast<BlockDecl>(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<NamedDecl>(D));

+    mangleUnqualifiedName(cast<NamedDecl>(D), AdditionalAbiTags);

   }