[libcxxabi][demangler] Add demangling for __attribute__((abi_tag))

[erik.pilkington]

Summary

This patch adds demangling support for __attribute__((abi_tag)). I.e, the following function: __attribute__((abi_tag("foo"))) void f() {} mangles to _Z1fB3foov, and now demangles to f[abi:foo]() (this syntax is the same as GCC's demangler). This patch parses the attribute everywhere in the grammer ItaniumMangle emits it.

While looking through ItaniumMangle, I noticed a couple of features that it supports that this file doesn't, so I added them to a list of them to the top. I'm going to submit some more patches for those as well.

https://bugs.llvm.org/show_bug.cgi?id=35310

Thanks for taking a look!

[EricWF]

src/cxa_demangle.cpp

10 ↗

(On Diff #123704)

Awesome comment!

If your awesomeness knows no bound, I would love to add currently-failing tests that demonstrate the FIXME.
Obviously that has no bearing on how this patch proceeds.

16 ↗

(On Diff #123704)

Urg...

Entirely unrelated to this patch, but manually defining _LIBCPP_NO_EXCEPTIONS here smells awful.

1848 ↗

(On Diff #123704)

I realize the unneeded blank line is part of the existing style... But I fudging hate it.

If you're not opposed I would love to start removing the unneeded line wherever it's
part of this changeset.

4353 ↗

(On Diff #123704)

Does this comment need updating now that <ctor-dtor-name> now parses with an optional ABI tag at the end?

4408 ↗

(On Diff #123704)

Does this comment need to be updated to reflect that <unnamed-type-name> now parses with an optional ABI tag after the _ character?

test/test_demangle.pass.cpp

29608 ↗

(On Diff #123704)

Perhaps it would be better to replace this blank line with a comment stating the tests below are for the ABI tag extension?

[erik.pilkington]

In this new patch:

• Update the comment BNF to show the new attribute, fix comment formatting
• Move call to parse_abi_tag_seq() from parse_unqualified_name() to parse_operator_name() to more closely model BNF

Thanks!

[erik.pilkington]

src/cxa_demangle.cpp

10 ↗

(On Diff #123704)

Sure, r318765

1848 ↗

(On Diff #123704)

I'm not opposed! The new patch removes it in the functions I touched

[EricWF]

LGTM. Thanks.

libcxxabi/trunk/src/cxa_demangle.cpp

 public:
   enum Kind : unsigned char {
     KDotSuffix,
     KVendorExtQualType,
     KQualType,
     KConversionOperatorType,
     KPostfixQualifiedType,
     KNameType,
+    KAbiTagAttr,
     KObjCProtoName,
     KPointerType,
     KLValueReferenceType,
     KRValueReferenceType,
     KPointerToMemberType,
     KArrayType,
     KFunctionType,
     KTopLevelFunctionDecl,
public:
   NameType(StringView Name_) : Node(KNameType), Name(Name_) {}
 
   StringView getName() const { return Name; }
   StringView getBaseName() const override { return Name; }
 
   void printLeft(OutputStream &s) const override { s += Name; }
 };
 
+class AbiTagAttr final : public Node {
+  const Node* Base;
+  StringView Tag;
+public:
+  AbiTagAttr(const Node* Base_, StringView Tag_)
+      : Node(KAbiTagAttr), Base(Base_), Tag(Tag_) {}
+
+  void printLeft(OutputStream &S) const override {
+    Base->printLeft(S);
+    S += "[abi:";
+    S += Tag;
+    S += "]";
+  }
+};
+
 class ObjCProtoName : public Node {
   Node *Ty;
   Node *Protocol;
 
   friend class PointerType;
 
 public:
   ObjCProtoName(Node *Ty_, Node *Protocol_)
parse_floating_number(const char* first, const char* last, Db& db)
     {
         db.Names.push_back(
             db.make<FloatExpr<Float>>(StringView(first, t)));
         first = t + 1;
     }
     return first;
 }
 
-// <source-name> ::= <positive length number> <identifier>
-
+// <positive length number> ::= [0-9]*
 const char*
-parse_source_name(const char* first, const char* last, Db& db)
+parse_positive_integer(const char* first, const char* last, size_t* out)
 {
     if (first != last)
     {
         char c = *first;
         if (isdigit(c) && first+1 != last)
         {
             const char* t = first+1;
             size_t n = static_cast<size_t>(c - '0');
             for (c = *t; isdigit(c); c = *t)
             {
                 n = n * 10 + static_cast<size_t>(c - '0');
                 if (++t == last)
                     return first;
             }
-            if (static_cast<size_t>(last - t) >= n)
-            {
-                StringView r(t, t + n);
-                if (r.substr(0, 10) == "_GLOBAL__N")
-                    db.Names.push_back(db.make<NameType>("(anonymous namespace)"));
-                else
-                    db.Names.push_back(db.make<NameType>(r));
-                first = t + n;
-            }
+            *out = n;
+            first = t;
+        }
+    }
+    return first;
+}
+
+// extension
+// <abi-tag-seq> ::= <abi-tag>*
+// <abi-tag>     ::= B <positive length number> <identifier>
+const char*
+parse_abi_tag_seq(const char* first, const char* last, Db& db)
+{
+    while (first != last && *first == 'B' && first+1 != last)
+    {
+        size_t length;
+        const char* t = parse_positive_integer(first+1, last, &length);
+        if (t == first+1)
+            return first;
+        if (static_cast<size_t>(last - t) < length || db.Names.empty())
+            return first;
+        db.Names.back() = db.make<AbiTagAttr>(
+            db.Names.back(), StringView(t, t + length));
+        first = t + length;
+    }
+    return first;
+}
+
+// <source-name> ::= <positive length number> <identifier> [<abi-tag-seq>]
+const char*
+parse_source_name(const char* first, const char* last, Db& db)
+{
+    if (first != last)
+        size_t length;
+        const char* t = parse_positive_integer(first, last, &length);
+        if (t == first)
+            return first;
+        if (static_cast<size_t>(last - t) >= length)
+        {
+            StringView r(t, t + length);
+            first = t + length;
+            first = parse_abi_tag_seq(first, last, db);
         }
     }
     return first;
 }
 
 // <substitution> ::= S <seq-id> _
 //                ::= S_
 // <substitution> ::= Sa # ::std::allocator

 //                   ::= ps    # + (unary)
 //                   ::= pt    # ->            
 //                   ::= qu    # ?             
 //                   ::= rm    # %             
 //                   ::= rM    # %=            
 //                   ::= rs    # >>            
 //                   ::= rS    # >>=           
 //                   ::= v <digit> <source-name>        # vendor extended operator
-
+//   extension       ::= <operator-name> <abi-tag-seq>
 const char*
 parse_operator_name(const char* first, const char* last, Db& db)
 {
+    const char* original_first = first;
     if (last - first >= 2)
     {
         switch (first[0])
         {
         case 'a':
             switch (first[1])
             {
             case 'a':
if (last - first >= 2)
                     db.Names.back() =
                         db.make<ConversionOperatorType>(db.Names.back());
                     first = t;
                 }
             }
             break;
         }
     }
+
+    if (original_first != first)
+        first = parse_abi_tag_seq(first, last, db);
+
     return first;
 }
 
 const char*
 parse_integer_literal(const char* first, const char* last, StringView lit, Db& db)
 {
     const char* t = parse_number(first, last);
     if (t != first && t != last && *t == 'E')

 // <ctor-dtor-name> ::= C1    # complete object constructor
 //                  ::= C2    # base object constructor
 //                  ::= C3    # complete object allocating constructor
 //   extension      ::= C5    # ?
 //                  ::= D0    # deleting destructor
 //                  ::= D1    # complete object destructor
 //                  ::= D2    # base object destructor
 //   extension      ::= D5    # ?
-
+//   extension      ::= <ctor-dtor-name> <abi-tag-seq>
 const char*
 parse_ctor_dtor_name(const char* first, const char* last, Db& db)
 {
     if (last-first >= 2 && !db.Names.empty())
     {
         switch (first[0])
         {
         case 'C':
             switch (first[1])
             {
             case '1':
             case '2':
             case '3':
             case '5':
                 if (db.Names.empty())
                     return first;
                 db.Names.back() =
                     maybe_change_special_sub_name(db.Names.back(), db);
                 db.Names.push_back(
                     db.make<CtorDtorName>(db.Names.back(), false));
                 first += 2;
+                first = parse_abi_tag_seq(first, last, db);
                 db.ParsedCtorDtorCV = true;
                 break;
             }
             break;
         case 'D':
             switch (first[1])
             {
             case '0':
             case '1':
             case '2':
             case '5':
                 if (db.Names.empty())
                     return first;
                 db.Names.push_back(
                     db.make<CtorDtorName>(db.Names.back(), true));
                 first += 2;
+                first = parse_abi_tag_seq(first, last, db);
                 db.ParsedCtorDtorCV = true;
                 break;
             }
             break;
         }
     }
     return first;
 }
 
-// <unnamed-type-name> ::= Ut [ <nonnegative number> ] _
+// <unnamed-type-name> ::= Ut [<nonnegative number>] _ [<abi-tag-seq>]
 //                     ::= <closure-type-name>
 // 
 // <closure-type-name> ::= Ul <lambda-sig> E [ <nonnegative number> ] _ 
 // 
 // <lambda-sig> ::= <parameter type>+  # Parameter types or "v" if the lambda has no parameters
-
 const char*
 parse_unnamed_type_name(const char* first, const char* last, Db& db)
 {
     if (last - first > 2 && first[0] == 'U')
     {
         char type = first[1];
         switch (type)
         {
if (last - first > 2 && first[0] == 'U')
                     ++t1;
                 count = StringView(t0, t1);
                 t0 = t1;
             }
             if (t0 == last || *t0 != '_')
                 return first;
             db.Names.push_back(db.make<UnnamedTypeName>(count));
             first = t0 + 1;
+            first = parse_abi_tag_seq(first, last, db);
           }
             break;
         case 'l':
           {
             size_t begin_pos = db.Names.size();
             const char* t0 = first+2;
             NodeArray lambda_params;
             if (first[2] == 'v')

libcxxabi/trunk/test/test_demangle.pass.cpp

//    {"_Z1fM1XRFivEMS_OFivEMS_KOFivE", "f(int (X::*)() &, int (X::*)() &&, int (X::*)() const &&)"},
     {"i", "int"},
 
     {"PKFvRiE", "void (*)(int&) const"},
     {"PVFvRmOE", "void (*)(unsigned long&) volatile &&"},
     {"PFvRmOE", "void (*)(unsigned long&) &&"},
     {"_ZTW1x", "thread-local wrapper routine for x"},
     {"_ZTHN3fooE", "thread-local initialization routine for foo"},
     {"_Z4algoIJiiiEEvZ1gEUlT_E_", "void algo<int, int, int>(g::'lambda'(int, int, int))"},
+    // attribute abi_tag
+    {"_Z1fB3foov", "f[abi:foo]()"},
+    {"_Z1fB3fooB3barv", "f[abi:foo][abi:bar]()"},
+    {"_ZN1SB5outer1fB5innerEv", "S[abi:outer]::f[abi:inner]()"},
+    {"_ZN1SC2B8ctor_tagEv", "S::S[abi:ctor_tag]()"},
+    {"_ZplB4MERP1SS_", "operator+[abi:MERP](S, S)"},
 };
 
 const unsigned N = sizeof(cases) / sizeof(cases[0]);
 
 struct FPLiteralCase {
     const char *mangled;
     // There are four possible demanglings of a given float.
     std::string expecting[4];