[demangler] Fix unresolvedname demangling

[urnathan]

Summary

As with ::new demangling (D118476), we were dropping the [gs] modifier by parsing it in parseExpr, but not forwarding it on to parseUnresolvedName. This is the straightforwards fix.

[ChuanqiXu]

BTW, in the case the patch has dependencies with each other, we should add the corresponding revision. In Web UI, we could make this in Edit Related Revisions in the top of the page.

[urnathan]

In D118504#3299875, @ChuanqiXu wrote:

BTW, in the case the patch has dependencies with each other, we should add the corresponding revision. In Web UI, we could make this in Edit Related Revisions in the top of the page.

thank you for the reminder. These patches were (intentionally) not interdependent to avoid that :)

libcxxabi/src/demangle/ItaniumDemangle.h

template <typename Derived, typename Alloc> struct AbstractManglingParser {
   Node *parseSourceName(NameState *State);
   Node *parseUnscopedName(NameState *State);
   Node *parseNestedName(NameState *State);
   Node *parseCtorDtorName(Node *&SoFar, NameState *State);
 
   Node *parseAbiTags(Node *N);
 
   /// Parse the <unresolved-name> production.
-  Node *parseUnresolvedName();
+  Node *parseUnresolvedName(bool Global);
   Node *parseSimpleId();
   Node *parseBaseUnresolvedName();
   Node *parseUnresolvedType();
   Node *parseDestructorName();
 
   /// Top-level entry point into the parser.
   Node *parse();
 };
Node *AbstractManglingParser<Derived, Alloc>::parseBaseUnresolvedName() {
   return Oper;
 }
 
 // <unresolved-name>
 //  extension        ::= srN <unresolved-type> [<template-args>] <unresolved-qualifier-level>* E <base-unresolved-name>
 //                   ::= [gs] <base-unresolved-name>                     # x or (with "gs") ::x
 //                   ::= [gs] sr <unresolved-qualifier-level>+ E <base-unresolved-name>
 //                                                                       # A::x, N::y, A<T>::z; "gs" means leading "::"
+// [gs] has been parsed by caller.
 //                   ::= sr <unresolved-type> <base-unresolved-name>     # T::x / decltype(p)::x
 //  extension        ::= sr <unresolved-type> <template-args> <base-unresolved-name>
 //                                                                       # T::N::x /decltype(p)::N::x
 //  (ignored)        ::= srN <unresolved-type>  <unresolved-qualifier-level>+ E <base-unresolved-name>
 //
 // <unresolved-qualifier-level> ::= <simple-id>
 template <typename Derived, typename Alloc>
-Node *AbstractManglingParser<Derived, Alloc>::parseUnresolvedName() {
+Node *AbstractManglingParser<Derived, Alloc>::parseUnresolvedName(bool Global) {
   Node *SoFar = nullptr;
 
   // srN <unresolved-type> [<template-args>] <unresolved-qualifier-level>* E <base-unresolved-name>
   // srN <unresolved-type>                   <unresolved-qualifier-level>+ E <base-unresolved-name>
   if (consumeIf("srN")) {
     SoFar = getDerived().parseUnresolvedType();
     if (SoFar == nullptr)
       return nullptr;
if (consumeIf("srN")) {
     }
 
     Node *Base = getDerived().parseBaseUnresolvedName();
     if (Base == nullptr)
       return nullptr;
     return make<QualifiedName>(SoFar, Base);
   }
 
-  bool Global = consumeIf("gs");
-
   // [gs] <base-unresolved-name>                     # x or (with "gs") ::x
   if (!consumeIf("sr")) {
     SoFar = getDerived().parseBaseUnresolvedName();
     if (SoFar == nullptr)
       return nullptr;
     if (Global)
       SoFar = make<GlobalQualifiedName>(SoFar);
     return SoFar;
case 'd':
     case 'l': {
       First += 2;
       Node *E = getDerived().parseExpr();
       if (E == nullptr)
         return E;
       return make<DeleteExpr>(E, Global, /*is_array=*/false);
     }
     case 'n':
-      return getDerived().parseUnresolvedName();
+      return getDerived().parseUnresolvedName(Global);
     case 's': {
       First += 2;
       Node *LHS = getDerived().parseExpr();
       if (LHS == nullptr)
         return nullptr;
       Node *RHS = getDerived().parseExpr();
       if (RHS == nullptr)
         return nullptr;
case 'x':
       if (Ex == nullptr)
         return Ex;
       return make<EnclosingExpr>("noexcept (", Ex, ")");
     }
     return nullptr;
   case 'o':
     switch (First[1]) {
     case 'n':
-      return getDerived().parseUnresolvedName();
+      return getDerived().parseUnresolvedName(Global);
     case 'o':
       First += 2;
       return getDerived().parseBinaryExpr("||");
     case 'r':
       First += 2;
       return getDerived().parseBinaryExpr("|");
     case 'R':
       First += 2;
case 's':
     case 'p': {
       First += 2;
       Node *Child = getDerived().parseExpr();
       if (Child == nullptr)
         return nullptr;
       return make<ParameterPackExpansion>(Child);
     }
     case 'r':
-      return getDerived().parseUnresolvedName();
+      return getDerived().parseUnresolvedName(Global);
     case 't': {
       First += 2;
       Node *Ty = getDerived().parseType();
       if (Ty == nullptr)
         return Ty;
       return make<EnclosingExpr>("sizeof (", Ty, ")");
     }
     case 'z': {
Node *AbstractManglingParser<Derived, Alloc>::parseExpr() {
   case '2':
   case '3':
   case '4':
   case '5':
   case '6':
   case '7':
   case '8':
   case '9':
-    return getDerived().parseUnresolvedName();
+    return getDerived().parseUnresolvedName(Global);
   }
   return nullptr;
 }
 
 // <call-offset> ::= h <nv-offset> _
 //               ::= v <v-offset> _
 //
 // <nv-offset> ::= <offset number>

libcxxabi/test/test_demangle.pass.cpp

//    {"_Z1fM1XRFivEMS_OFivEMS_KOFivE", "f(int (X::*)() &, int (X::*)() &&, int (X::*)() const &&)"},
     {"_Z3fooILi79EEbU7_ExtIntIXT_EEi", "bool foo<79>(int _ExtInt<79>)"},
 
     {"_ZN3xxx3yyyIvNS_1AILm0EEEZNS_2bb2cc2ddILNS_1eE1EEEvRKNS_1fERKNS_1g1hINS_1iEEERKNS_1jEfRKNS_1kEiPhEUlvE_JEEEvT1_DpT2_", "void xxx::yyy<void, xxx::A<0ul>, void xxx::bb::cc::dd<(xxx::e)1>(xxx::f const&, xxx::g::h<xxx::i> const&, xxx::j const&, float, xxx::k const&, int, unsigned char*)::'lambda'()>(void xxx::bb::cc::dd<(xxx::e)1>(xxx::f const&, xxx::g::h<xxx::i> const&, xxx::j const&, float, xxx::k const&, int, unsigned char*)::'lambda'())"},
 
     // This should be invalid, but it is currently not recognized as such
     // See https://llvm.org/PR51407
     {"_Zcv1BIRT_EIS1_E", "operator B<><>"},
 
+    {"_ZN2FnIXgs4BaseEX4BaseEEEvv","void Fn<::Base, Base>()"},
+    
     {"_Z3TPLIiET_S0_", "int TPL<int>(int)"},
 };
 
 const unsigned N = sizeof(cases) / sizeof(cases[0]);
 
 struct FPLiteralCase {
     const char *mangled;
     // There are four possible demanglings of a given float.

llvm/include/llvm/Demangle/ItaniumDemangle.h

template <typename Derived, typename Alloc> struct AbstractManglingParser {
   Node *parseSourceName(NameState *State);
   Node *parseUnscopedName(NameState *State);
   Node *parseNestedName(NameState *State);
   Node *parseCtorDtorName(Node *&SoFar, NameState *State);
 
   Node *parseAbiTags(Node *N);
 
   /// Parse the <unresolved-name> production.
-  Node *parseUnresolvedName();
+  Node *parseUnresolvedName(bool Global);
   Node *parseSimpleId();
   Node *parseBaseUnresolvedName();
   Node *parseUnresolvedType();
   Node *parseDestructorName();
 
   /// Top-level entry point into the parser.
   Node *parse();
 };
Node *AbstractManglingParser<Derived, Alloc>::parseBaseUnresolvedName() {
   return Oper;
 }
 
 // <unresolved-name>
 //  extension        ::= srN <unresolved-type> [<template-args>] <unresolved-qualifier-level>* E <base-unresolved-name>
 //                   ::= [gs] <base-unresolved-name>                     # x or (with "gs") ::x
 //                   ::= [gs] sr <unresolved-qualifier-level>+ E <base-unresolved-name>
 //                                                                       # A::x, N::y, A<T>::z; "gs" means leading "::"
+// [gs] has been parsed by caller.
 //                   ::= sr <unresolved-type> <base-unresolved-name>     # T::x / decltype(p)::x
 //  extension        ::= sr <unresolved-type> <template-args> <base-unresolved-name>
 //                                                                       # T::N::x /decltype(p)::N::x
 //  (ignored)        ::= srN <unresolved-type>  <unresolved-qualifier-level>+ E <base-unresolved-name>
 //
 // <unresolved-qualifier-level> ::= <simple-id>
 template <typename Derived, typename Alloc>
-Node *AbstractManglingParser<Derived, Alloc>::parseUnresolvedName() {
+Node *AbstractManglingParser<Derived, Alloc>::parseUnresolvedName(bool Global) {
   Node *SoFar = nullptr;
 
   // srN <unresolved-type> [<template-args>] <unresolved-qualifier-level>* E <base-unresolved-name>
   // srN <unresolved-type>                   <unresolved-qualifier-level>+ E <base-unresolved-name>
   if (consumeIf("srN")) {
     SoFar = getDerived().parseUnresolvedType();
     if (SoFar == nullptr)
       return nullptr;
if (consumeIf("srN")) {
     }
 
     Node *Base = getDerived().parseBaseUnresolvedName();
     if (Base == nullptr)
       return nullptr;
     return make<QualifiedName>(SoFar, Base);
   }
 
-  bool Global = consumeIf("gs");
-
   // [gs] <base-unresolved-name>                     # x or (with "gs") ::x
   if (!consumeIf("sr")) {
     SoFar = getDerived().parseBaseUnresolvedName();
     if (SoFar == nullptr)
       return nullptr;
     if (Global)
       SoFar = make<GlobalQualifiedName>(SoFar);
     return SoFar;
case 'd':
     case 'l': {
       First += 2;
       Node *E = getDerived().parseExpr();
       if (E == nullptr)
         return E;
       return make<DeleteExpr>(E, Global, /*is_array=*/false);
     }
     case 'n':
-      return getDerived().parseUnresolvedName();
+      return getDerived().parseUnresolvedName(Global);
     case 's': {
       First += 2;
       Node *LHS = getDerived().parseExpr();
       if (LHS == nullptr)
         return nullptr;
       Node *RHS = getDerived().parseExpr();
       if (RHS == nullptr)
         return nullptr;
case 'x':
       if (Ex == nullptr)
         return Ex;
       return make<EnclosingExpr>("noexcept (", Ex, ")");
     }
     return nullptr;
   case 'o':
     switch (First[1]) {
     case 'n':
-      return getDerived().parseUnresolvedName();
+      return getDerived().parseUnresolvedName(Global);
     case 'o':
       First += 2;
       return getDerived().parseBinaryExpr("||");
     case 'r':
       First += 2;
       return getDerived().parseBinaryExpr("|");
     case 'R':
       First += 2;
case 's':
     case 'p': {
       First += 2;
       Node *Child = getDerived().parseExpr();
       if (Child == nullptr)
         return nullptr;
       return make<ParameterPackExpansion>(Child);
     }
     case 'r':
-      return getDerived().parseUnresolvedName();
+      return getDerived().parseUnresolvedName(Global);
     case 't': {
       First += 2;
       Node *Ty = getDerived().parseType();
       if (Ty == nullptr)
         return Ty;
       return make<EnclosingExpr>("sizeof (", Ty, ")");
     }
     case 'z': {
Node *AbstractManglingParser<Derived, Alloc>::parseExpr() {
   case '2':
   case '3':
   case '4':
   case '5':
   case '6':
   case '7':
   case '8':
   case '9':
-    return getDerived().parseUnresolvedName();
+    return getDerived().parseUnresolvedName(Global);
   }
   return nullptr;
 }
 
 // <call-offset> ::= h <nv-offset> _
 //               ::= v <v-offset> _
 //
 // <nv-offset> ::= <offset number>