PR30401: Fix substitutions for functions with abi_tag

[DmitryPolukhin]

Summary

Recursive mangling should use all existing substitutions and newly created substitutions should be copied outer mangler.

This patch should fix PR30401 and related cases but unfortunately it is ABI breaking change for Clang backward compatibility (I hope it is rare case in practice). Perhaps this patch will have to be back ported to 3.9.

[rsmith]

lib/AST/ItaniumMangle.cpp

669

Maybe it'd be simpler to just override the output stream here rather than creating a new mangler?

[DmitryPolukhin]

lib/AST/ItaniumMangle.cpp

669

I'm not sure that it is simpler because it will also require substitutions save/restore for name mangling (mangleNameWithAbiTags) to produce the same substitutions twice (without implicate abi_tags and later with implicit abi_tags). IMHO, it is almost identical approaches but current one is a bit cleaner because it copies explicitly everything required from temp to outer mangler.

[rsmith]

lib/AST/ItaniumMangle.cpp

669

I think we'd want to override the output stream to write to a temporary buffer at the point when we would otherwise write out the ABI tags, to avoid needing to save/restore any substitutions. But I agree, that seems more invasive than what you're doing here. I'll leave this up to you.

4440

Please avoid the cost of a full copy here by making this a destructive operation on Other -- use swap or move-assignment here. (We'll still be paying for one copy of the substitution set per function mangling, which is unfortunate / undesirable.)

[DmitryPolukhin]

lib/AST/ItaniumMangle.cpp

669

It is significant redesign and additional complexity to remember which exactly ABI tags we would like to rewrite later (it may not be the first call of writeAbiTags for current mangler). I would keep it as is.

[DmitryPolukhin]

Richard, please take another look.

[DmitryPolukhin]

Committed as rL282059

lib/AST/ItaniumMangle.cpp

public:
   CXXNameMangler(ItaniumMangleContextImpl &C, raw_ostream &Out_,
                  const CXXDestructorDecl *D, CXXDtorType Type)
     : Context(C), Out(Out_), Structor(getStructor(D)), StructorType(Type),
       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) {}
+        SeqID(Outer.SeqID), AbiTagsRoot(AbiTags),
+        Substitutions(Outer.Substitutions) {}
 
   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) {}
+        SeqID(Outer.SeqID), AbiTagsRoot(AbiTags),
+        Substitutions(Outer.Substitutions) {}
 
 #if MANGLE_CHECKER
   ~CXXNameMangler() {
     if (Out.str()[0] == '\01')
       return;
 
     int status = 0;
     char *result = abi::__cxa_demangle(Out.str().str().c_str(), 0, 0, &status);
private:
   void addSubstitution(const NamedDecl *ND) {
     ND = cast<NamedDecl>(ND->getCanonicalDecl());
 
     addSubstitution(reinterpret_cast<uintptr_t>(ND));
   }
   void addSubstitution(QualType T);
   void addSubstitution(TemplateName Template);
   void addSubstitution(uintptr_t Ptr);
+  // Destructive copy substitutions from other mangler.
+  void extendSubstitutions(CXXNameMangler* Other);
 
   void mangleUnresolvedPrefix(NestedNameSpecifier *qualifier,
                               bool recursive = false);
   void mangleUnresolvedName(NestedNameSpecifier *qualifier,
                             DeclarationName name,
                             unsigned KnownArity = UnknownArity);
 
   void mangleFunctionEncodingBareType(const FunctionDecl *FD);
if (ReturnTypeAbiTags.empty()) {
     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);
+
+  // Function encoding could create new substitutions so we have to add
+  // temp mangled substitutions to main mangler.
+  extendSubstitutions(&FunctionEncodingMangler);
 }
 
 void CXXNameMangler::mangleFunctionEncodingBareType(const FunctionDecl *FD) {
   if (FD->hasAttr<EnableIfAttr>()) {
     FunctionTypeDepthState Saved = FunctionTypeDepth.push();
     Out << "Ua9enable_ifI";
     // FIXME: specific_attr_iterator iterates in reverse order. Fix that and use
     // it here.
void CXXNameMangler::addSubstitution(TemplateName Template) {
   addSubstitution(reinterpret_cast<uintptr_t>(Template.getAsVoidPointer()));
 }
 
 void CXXNameMangler::addSubstitution(uintptr_t Ptr) {
   assert(!Substitutions.count(Ptr) && "Substitution already exists!");
   Substitutions[Ptr] = SeqID++;
 }
 
+void CXXNameMangler::extendSubstitutions(CXXNameMangler* Other) {
+  assert(Other->SeqID >= SeqID && "Must be superset of substitutions!");
+  if (Other->SeqID > SeqID) {
+    Substitutions.swap(Other->Substitutions);
+    SeqID = Other->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);

test/CodeGenCXX/mangle-abi-tag.cpp

 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 {{.+}} @_ZN3A18cv1AB1AB1BEv(
+
+namespace N19 {
+  class A {};
+  class __attribute__((abi_tag("B"))) B {};
+  class D {};
+  class F {};
+
+  template<typename T, B F(T, D)>
+  class C {};
+
+  B foo(A, D);
+}
+void f19_test(N19::C<N19::A,  &N19::foo>, N19::F, N19::D) {
+}
+// f19_test(N19::C<N19::A, &N19::foo[abi:B]>, N19::F, N19::D)
+// CHECK-DAG: define void @_Z8f19_testN3N191CINS_1AEXadL_ZNS_3fooB1BES1_NS_1DEEEEENS_1FES2_(