[libcxxabi][demangler] Special case demangling for pass_object_size attribute

[erik.pilkington]

Summary

This patch adds demangling for pass_object_size attribute (https://clang.llvm.org/docs/AttributeReference.html#pass-object-size). This attribute applies to function parameters. This attribute is mangled as if it was meant to match the <extended-qualifier> production (https://itanium-cxx-abi.github.io/cxx-abi/abi.html#mangle.qualified-type), but clang emits it after the type it refers to instead of before. I think this was a mistake, but its probably too late to fix it because of the ABI break.

Thanks for taking a look!
Erik

[george.burgess.iv]

Thanks for working on this!

Unfortunately, I've never touched demanglers before, so I don't think I can LGTM this patch.

This attribute is mangled as if it was meant to match the <extended-qualifier> production.

Yup, definitely a mistake. Apologies. :)

test/test_demangle.pass.cpp

29618

Nit: Can we have a test with pass_object_size(1) (or 2, or 3. Any of the 3 WFM), as well?

[erik.pilkington]

Add a testcase with pass_object_size[0-3].

src/cxa_demangle.cpp

 //===-------------------------- cxa_demangle.cpp --------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // FIXME: (possibly) incomplete list of features that clang mangles that this
 // file does not yet support:
 //   - enable_if attribute
 //   - decomposition declarations
 //   - C++ modules TS
+//   - inheriting constructors
 
 #define _LIBCPP_NO_EXCEPTIONS
 
 #include "__cxxabi_config.h"
 
 #include <vector>
 #include <algorithm>
 #include <numeric>

                     db.Names.back(), "->", tmp);
                 first = t1;
             }
         }
     }
     return first;
 }
 
+// Parse a type in the context of a function parameter. Here, the type can be
+// optionally followed by a pass_object_size attribute. Unlike other vendor
+// extension attributes, clang emits this attribute after the mangling for the
+// type it applies to, so we have to special-case it.
+//
+// <type> ::= <type> U17pass_object_size [0-9] # extension
+const char*
+parse_function_param_type(const char* first, const char* last, Db& db)
+{
+    const char* t = parse_type(first, last, db);
+    if (t != first && StringView(t, last).startsWith("U17pass_object_size"))
+    {
+        const char* t2 = t + std::strlen("U17pass_object_size");
+        if (t2 != last && *t2 >= '0' && *t2 <= '9' && !db.Names.empty())
+        {
+            db.Names.back() = db.make<VendorExtQualType>(
+                db.make<NameType>(StringView(t+3, t2+1)), db.Names.back());
+            t = t2+1;
+        }
+    }
+    return t;
+}
+
 //  <ref-qualifier> ::= R                   # & ref-qualifier
 //  <ref-qualifier> ::= O                   # && ref-qualifier
-
-// <function-type> ::= F [Y] <bare-function-type> [<ref-qualifier>] E
-
+//
+//  <function-type> ::= F [Y] <bare-function-type> [<ref-qualifier>] E
 const char*
 parse_function_type(const char* first, const char* last, Db& db)
 {
     if (first != last && *first == 'F')
     {
         const char* t = first+1;
         if (t != last)
         {

                     }
                     if (*t == 'O' && t+1 != last && t[1] == 'E')
                     {
                         RefQuals = FrefQualRValue;
                         ++t;
                         continue;
                     }
                     size_t k0 = db.Names.size();
-                    t1 = parse_type(t, last, db);
+                    t1 = parse_function_param_type(t, last, db);
                     size_t k1 = db.Names.size();
                     if (t1 == t || t1 == last || k1 < k0)
                         return first;
                     t = t1;
                 }
                 if (db.Names.empty() || params_begin > db.Names.size())
                     return first;
                 Node* fty = db.make<FunctionType>(

             if (first[2] == 'v')
             {
                 ++t0;
             }
             else
             {
                 while (true)
                 {
-                    const char* t1 = parse_type(t0, last, db);
+                    const char* t1 = parse_function_param_type(t0, last, db);
                     if (t1 == t0)
                         break;
                     t0 = t1;
                 }
                 if (db.Names.size() < begin_pos)
                     return first;
                 lambda_params = db.popTrailingNodeArray(begin_pos);
             }

                         result = db.make<TopLevelFunctionDecl>(
                             return_type, name, NodeArray());
                     }
                     else
                     {
                         size_t params_begin = db.Names.size();
                         while (true)
                         {
-                            t2 = parse_type(t, last, db);
+                            t2 = parse_function_param_type(t, last, db);
                             if (t2 == t)
                                 break;
                             t = t2;
                         }
                         if (db.Names.size() < params_begin)
                             return first;
                         NodeArray params =
                             db.popTrailingNodeArray(params_begin);

test/test_demangle.pass.cpp

     {"_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)"},
+    // attribute pass_object_size
+    {"_Z27NoViableOverloadObjectSize0PvU17pass_object_size0", "NoViableOverloadObjectSize0(pass_object_size0 void*)"},
+    {"_ZN14noninline_virt1AC2EiO1QPvU17pass_object_size0", "noninline_virt::A::A(int, Q&&, pass_object_size0 void*)"},
+    {"_ZZN7lambdas7LambdasEPcENK3$_0clEPvU17pass_object_size0", "lambdas::Lambdas(char*)::$_0::operator()(pass_object_size0 void*) const"},
+    {"_ZN8variadic6AsCtorC1EPKcU17pass_object_size0dz", "variadic::AsCtor::AsCtor(pass_object_size0 char const*, double, ...)"},
+    {"_Z1fPvU17pass_object_size0S_U17pass_object_size1S_U17pass_object_size2S_U17pass_object_size3", "f(pass_object_size0 void*, pass_object_size1 void*, pass_object_size2 void*, pass_object_size3 void*)"},
 };
 
 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];