[demangler] Add a "partial" demangling API for LLDB

[erik.pilkington]

Summary

lldb-dev thread: http://lists.llvm.org/pipermail/lldb-dev/2018-January/013186.html

Currently, the demangler in ItaniumDemangler works by parsing the mangled name into an AST-like format, then traverses that AST to produce the demangled name. Some users (LLDB) consume this demangled name by writing custom parsers. This is redundant (in a very hot section, AFAIK), as the name has to be printed and the re-parsed. For large demangled names with many (potentially nested) <template-param>s and substitutions, the demangler has to produce a massive symbol that LLDB has to dig through in order to find the small amount of information that it needs. Just parsing to an AST expands no substitutions, and should run in about O(strlen of the mangled name).

This patch adds a partial demangling API that parses the mangled name into the AST-like format without printing and provides some functions to access interesting information from that AST. If LLDB used this instead of char*s to investigate the demangled name, it would be cleaner and save time. (AFAIK, I've never touched lldb!)

I've put this patch up super early, I still want to add more tests and make it more robust. I'm hoping that this would be a good place to find out if this is what the LLDB people actually want. Does anyone have any thoughts?

Thanks for taking a look!
Erik

[davide]

It would be awesome if you could benchmark on some pathological testcases (e.g. the one Greg was pointing out)

_ZNK3shk6detail17CallbackPublisherIZNS_5ThrowERKNSt15__exception_ptr13exception_ptrEEUlOT_E_E9SubscribeINS0_9ConcatMapINS0_18CallbackSubscriberIZNS_6GetAllIiNS1_IZZNS_9ConcatMapIZNS_6ConcatIJNS1_IZZNS_3MapIZZNS_7IfEmptyIS9_EEDaS7_ENKUlS6_E_clINS1_IZZNS_4TakeIiEESI_S7_ENKUlS6_E_clINS1_IZZNS_6FilterIZNS_9ElementAtEmEUlS7_E_EESI_S7_ENKUlS6_E_clINS1_IZZNSL_ImEESI_S7_ENKUlS6_E_clINS1_IZNS_4FromINS0_22InfiniteRangeContainerIiEEEESI_S7_EUlS7_E_EEEESI_S6_EUlS7_E_EEEESI_S6_EUlS7_E_EEEESI_S6_EUlS7_E_EEEESI_S6_EUlS7_E_EESI_S7_ENKUlS6_E_clIS14_EESI_S6_EUlS7_E_EERNS1_IZZNSH_IS9_EESI_S7_ENKSK_IS14_EESI_S6_EUlS7_E0_EEEEESI_DpOT_EUlS7_E_EESI_S7_ENKUlS6_E_clINS1_IZNS_5StartIJZNS_4JustIJS19_S1C_EEESI_S1F_EUlvE_ZNS1K_IJS19_S1C_EEESI_S1F_EUlvE0_EEESI_S1F_EUlS7_E_EEEESI_S6_EUlS7_E_EEEESt6vectorIS6_SaIS6_EERKT0_NS_12ElementCountEbEUlS7_E_ZNSD_IiS1Q_EES1T_S1W_S1X_bEUlOS3_E_ZNSD_IiS1Q_EES1T_S1W_S1X_bEUlvE_EES1G_S1O_E25ConcatMapValuesSubscriberEEEDaS7_

[jingham]

That seems great. This would be the backing for the CPlusPlusLanguage::MethodName class (in lldb in Source/Plugins/Language/CPlusPlus/CPlusPlusLanguage.h). It looks like a great fit for that.

I can't think of anything else we really wanted out of these names that you aren't currently providing. Greg might. But this looks like a great start to me.

[clayborg]

Seems like it might be nice to replace all "char *Buf, size_t *N" arguments, where "char *" is returned with a llvm::raw_ostream and let the user use what ever backing / memory allocation scheme they want instead of forcing re-allocations? Probably best to include a person that has contributed to this file in the LLVM community so they can comment on the changes here.

llvm/include/llvm/Demangle/Demangle.h

42

Use "llvm::StringRef MangledName" instead of "const char *"?

46

Might be better to use a "llvm::raw_ostream &out" instead of just a plain buffer? Seems like llvm::raw_ostream can be backed by what ever kind of buffer you want it to be backed (llvm::raw_string_ostream is a nice thing to use with this that uses a std::string as the destination buffer).

54

Maybe rename to getFunctionDeclContext? or getFunctionDeclContextName?

64

s/provably/probably/ in comment and function name. Maybe "couldBeMemberFunction" might be a better name?

69

Can you document what a special name is here?

[clayborg]

Great stuff, thanks for doing this BTW

[erik.pilkington]

It would be awesome if you could benchmark on some pathological testcases (e.g. the one Greg was pointing out)

As of r327690, the pathological symbol Greg posted is much smaller, due to a bug in how the demangler parsed generic lambda parameters. Now, partially demangling that symbol and getting the basename "Subscribe" is about 20x faster than fully demangling the name. Just for fun I removed the fix and benchmarked it again and it was more in the ballpark of hundreds of thousands of times faster. For more realistic symbols (test case being all the symbols in LLVM), partially demangling and extracting the basename runs in about 40% less time than fully demangling. Partially demangling and splitting up the entire name runs in about as long as the full demangle, but it should be faster if LLDB avoids parsing the demangled name. Depending on how LLDB is consuming these names, it might be profitable to do a first pass to find the base names of all the symbols in the program, then lazily demangle the other components as needed.

Seems like it might be nice to replace all "char *Buf, size_t *N" arguments, where "char *" is returned with a llvm::raw_ostream and let the user use what ever backing / memory allocation scheme they want instead of forcing re-allocations? Probably best to include a person that has contributed to this file in the LLVM community so they can comment on the changes here.

@rafael: Any thoughts? I think it would be nice to use LLVM data structures to express this API and have the no-dependencies demangler live in libcxxabi.

Thanks!

llvm/include/llvm/Demangle/Demangle.h

64

That wasn't a typo, this function checks if the name is for sure a non-static member function, so it conservatively returns false for a::b(). I suppose isDefinitelyMemberFunction() might be more clear.

[clayborg]

llvm/include/llvm/Demangle/Demangle.h

64

Maybe just "isMemberFunction()" would be clear enough? Don't think Definitely needs to be in the name.

[labath]

This looks great. Thank you for doing this.

llvm/include/llvm/Demangle/Demangle.h

64

I think that having something in the name which indicates this is just a best-effort guess is a good idea.

Alternatively, we could replace this function with something more well-defined (getFunctionQualifiers ? hasFunctionQualifiers?) and leave the business of guessing the member-ness of the function to lldb.

[erik.pilkington]

In this new patch:

• Rename some functions, add some comments
• Support for local names
• More testcases

[erik.pilkington]

Use Rafael's Phab account.

llvm/include/llvm/Demangle/Demangle.h

42

On second thought, I don't think we can use LLVM data structures for this. libSupport depends on libDemangle, so using any LLVM stuff would create a circular dependency. (I'm basing this off the commit message for r328072)

46

This has the same problem as above, but also raw_ostream isn't compatible with our how the AST is printed (Sometimes the printer look back at the last char).

54

Sure, I called this getFunctionDeclContextName() in the new patch.

64

I agree it would be better to indicate that this is only a best effort guess. hasFunctionQualifiers sounds good, I renamed this function to that in the new patch.

[erik.pilkington]

Rebase. In this new patch:

• Add some more tests.
• Minor cleanup.

I think I'm happy with the implementation of this now, so I'll land it as long as this API looks okay.

[clayborg]

Looks good to me, but probably need someone that works on LLVM fulltime to give the final ok

[davide]

I don't have objections to this one either. Maybe @majnemer / @espindola / @rnk / @Bigcheese have comment on the API?

[erik.pilkington]

I'll CC @dexonsmith and @compnerd too, they've helped with demangler reviews in the past.

[• espindola]

I don't have an opinion on this.

[dexonsmith]

I'd prefer to have this be as close as possible to the libcxxabi demangler (and use the same data structures) so that it's easy to detect when they diverge. If we ever move to monorepo hopefully there will be a way to factor them out into a single implementation.

Since that's where this ended up, LGTM!

llvm/include/llvm/Demangle/Demangle.h

 //===--- Demangle.h ---------------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include <cstddef>
+#include <utility>
 
 namespace llvm {
 /// This is a llvm local version of __cxa_demangle. Other than the name and
 /// being in the llvm namespace it is identical.
 ///
 /// The mangled_name is demangled into buf and returned. If the buffer is not
 /// large enough, realloc is used to expand it.
 ///
 /// The *status will be set to
 ///   unknown_error: -4
 ///   invalid_args:  -3
 ///   invalid_mangled_name: -2
 ///   memory_alloc_failure: -1
 ///   success: 0
 
 char *itaniumDemangle(const char *mangled_name, char *buf, size_t *n,
                       int *status);
-}
+
+/// "Partial" demangler. This supports demangling a string into an AST
+/// (typically an intermediate stage in itaniumDemangle) and querying certain
+/// properties or partially printing the demangled name.
+struct ItaniumPartialDemangler {
+  ItaniumPartialDemangler();
+  ItaniumPartialDemangler(ItaniumPartialDemangler &&Other);
+  ItaniumPartialDemangler &operator=(ItaniumPartialDemangler &&Other);
+  ~ItaniumPartialDemangler();
+
+  /// Demangle into an AST. Subsequent calls to the rest of the member functions
+  /// implicitly operate on the AST this produces.
+  /// \return true on error, false otherwise
+  bool partialDemangle(const char *MangledName);
+
+  /// Just print the entire mangled name into Buf. Buf and N behave like the
+  /// second and third parameters to itaniumDemangle.
+  char *finishDemangle(char *Buf, size_t *N) const;
+
+  /// Get the base name of a function. This doesn't include trailing template
+  /// arguments, ie for "a::b<int>" this function returns "b".
+  char *getFunctionBaseName(char *Buf, size_t *N) const;
+
+  /// Get the context name for a function. For "a::b::c", this function returns
+  /// "a::b".
+  char *getFunctionContextName(char *Buf, size_t *N) const;
+
+  /// Get the entire name of this function.
+  char *getFunctionName(char *Buf, size_t *N) const;
+
+  /// Get the parameters for this function.
+  char *getFunctionParameters(char *Buf, size_t *N) const;
+
+  /// If this function is provably a non-static member function. We can only
+  /// know this if the function has a cv or reference qualifier.
+  bool isProvablyMemberFunction() const;
+
+  /// If this name is a function.
+  bool isFunction() const;
+
+  /// If this name is a special name.
+  bool isSpecialName() const;
+
+private:
+  void *RootNode;
+  void *Context;
+};
+} // namespace llvm

llvm/lib/Demangle/ItaniumDemangle.cpp

public:
 
   void printLeft(OutputStream &S) const override {
     S += Kind;
     S += ' ';
     Child->print(S);
   }
 };
 
-class AbiTagAttr final : public Node {
-  const Node* Base;
+struct AbiTagAttr : Node {
+  Node* Base;
   StringView Tag;
-public:
-  AbiTagAttr(const Node* Base_, StringView Tag_)
+
+  AbiTagAttr(Node* Base_, StringView Tag_)
       : Node(KAbiTagAttr, Base_->ParameterPackSize, Base_->RHSComponentCache,
              Base_->ArrayCache, Base_->FunctionCache),
         Base(Base_), Tag(Tag_) {}
 
   void printLeft(OutputStream &S) const override {
     Base->printLeft(S);
     S += "[abi:";
     S += Tag;
FunctionEncoding(Node *Ret_, Node *Name_, NodeArray Params_,
         Ret(Ret_), Name(Name_), Params(Params_), CVQuals(CVQuals_),
         RefQual(RefQual_) {
     for (Node *P : Params)
       ParameterPackSize = std::min(ParameterPackSize, P->ParameterPackSize);
     if (Ret)
       ParameterPackSize = std::min(ParameterPackSize, Ret->ParameterPackSize);
   }
 
+  Qualifiers getCVQuals() const { return CVQuals; }
+  FunctionRefQual getRefQual() const { return RefQual; }
+  NodeArray getParams() const { return Params; }
+
   bool hasRHSComponentSlow(OutputStream &) const override { return true; }
   bool hasFunctionSlow(OutputStream &) const override { return true; }
 
   Node *getName() { return const_cast<Node *>(Name); }
 
   void printLeft(OutputStream &S) const override {
     if (Ret) {
       Ret->printLeft(S);
public:
   void printLeft(OutputStream &S) const override {
     S += "construction vtable for ";
     FirstType->print(S);
     S += "-in-";
     SecondType->print(S);
   }
 };
 
-class QualifiedName final : public Node {
+struct QualifiedName : Node {
   // qualifier::name
-  const Node *Qualifier;
-  const Node *Name;
+  Node *Qualifier;
+  Node *Name;
 
-public:
   QualifiedName(Node* Qualifier_, Node* Name_)
       : Node(KQualifiedName,
              std::min(Qualifier_->ParameterPackSize, Name_->ParameterPackSize)),
         Qualifier(Qualifier_), Name(Name_) {}
 
   StringView getBaseName() const override { return Name->getBaseName(); }
+  Node *getQualifier() const { return Qualifier; }
 
   void printLeft(OutputStream &S) const override {
     Qualifier->print(S);
     S += "::";
     Name->print(S);
   }
 };
 
for (size_t Idx = 0, E = Params.size(); Idx != E; ++Idx) {
       Params[Idx]->print(S);
     }
     if (S.back() == '>')
       S += " ";
     S += ">";
   }
 };
 
-class NameWithTemplateArgs final : public Node {
+struct NameWithTemplateArgs : Node {
   // name<template_args>
   Node *Name;
   Node *TemplateArgs;
 
-public:
   NameWithTemplateArgs(Node *Name_, Node *TemplateArgs_)
       : Node(KNameWithTemplateArgs, std::min(Name_->ParameterPackSize,
                                              TemplateArgs_->ParameterPackSize)),
         Name(Name_), TemplateArgs(TemplateArgs_) {}
 
   StringView getBaseName() const override { return Name->getBaseName(); }
 
   void printLeft(OutputStream &S) const override {
     Name->print(S);
     TemplateArgs->print(S);
   }
 };
 
-class GlobalQualifiedName final : public Node {
+struct GlobalQualifiedName : Node {
   Node *Child;
 
-public:
   GlobalQualifiedName(Node* Child_)
       : Node(KGlobalQualifiedName, Child_->ParameterPackSize), Child(Child_) {}
 
   StringView getBaseName() const override { return Child->getBaseName(); }
 
   void printLeft(OutputStream &S) const override {
     S += "::";
     Child->print(S);
   }
 };
 
-class StdQualifiedName final : public Node {
+struct StdQualifiedName : Node {
   Node *Child;
 
-public:
   StdQualifiedName(Node *Child_)
       : Node(KStdQualifiedName, Child_->ParameterPackSize), Child(Child_) {}
 
   StringView getBaseName() const override { return Child->getBaseName(); }
 
   void printLeft(OutputStream &S) const override {
     S += "std::";
     Child->print(S);
case SpecialSubKind::ostream:
       break;
     case SpecialSubKind::iostream:
       S += "std::iostream";
       break;
     }
   }
 };
 
-class CtorDtorName final : public Node {
-  const Node *Basename;
-  const bool IsDtor;
+struct CtorDtorName : Node {
+  Node *Basename;
+  bool IsDtor;
 
-public:
   CtorDtorName(Node *Basename_, bool IsDtor_)
       : Node(KCtorDtorName, Basename_->ParameterPackSize),
         Basename(Basename_), IsDtor(IsDtor_) {}
 
   void printLeft(OutputStream &S) const override {
     if (IsDtor)
       S += "~";
     S += Basename->getBaseName();
if (N + BlockList->Current >= UsableAllocSize) {
         return allocateMassive(N);
       grow();
     }
     BlockList->Current += N;
     return static_cast<void*>(reinterpret_cast<char*>(BlockList + 1) +
                               BlockList->Current - N);
   }
 
-  ~BumpPointerAllocator() {
+  void reset() {
     while (BlockList) {
       BlockMeta* Tmp = BlockList;
       BlockList = BlockList->Next;
       if (reinterpret_cast<char*>(Tmp) != InitialBuffer)
         delete[] reinterpret_cast<char*>(Tmp);
     }
+    BlockList = new (InitialBuffer) BlockMeta{nullptr, 0};
   }
+
+  ~BumpPointerAllocator() { reset(); }
 };
 
 template <class T, size_t N>
 class PODSmallVector {
   static_assert(std::is_pod<T>::value,
                 "T is required to be a plain old data type");
 
   T* First;
struct Db {
   bool FixForwardReferences = false;
   bool TryToParseTemplateArgs = true;
   bool ParsingLambdaParams = false;
 
   BumpPointerAllocator ASTAllocator;
 
   Db(const char *First_, const char *Last_) : First(First_), Last(Last_) {}
 
+  void reset(const char *First_, const char *Last_) {
+    First = First_;
+    Last = Last_;
+    Names.clear();
+    Subs.clear();
+    TemplateParams.clear();
+    EncodingDepth = 0;
+    TagTemplates = FixForwardReferences = ParsingLambdaParams = false;
+    TryToParseTemplateArgs = true;
+    ASTAllocator.reset();
+  }
+
   template <class T, class... Args> T *make(Args &&... args) {
     return new (ASTAllocator.allocate(sizeof(T)))
         T(std::forward<Args>(args)...);
   }
 
   template <class It> NodeArray makeNodeArray(It begin, It end) {
     size_t sz = static_cast<size_t>(end - begin);
     void *mem = ASTAllocator.allocate(sizeof(Node *) * sz);
if (InternalStatus == success) {
     } else
       InternalStatus = memory_alloc_failure;
   }
 
   if (Status)
     *Status = InternalStatus;
   return InternalStatus == success ? Buf : nullptr;
 }
+
+namespace llvm {
+
+ItaniumPartialDemangler::ItaniumPartialDemangler()
+    : RootNode(nullptr), Context(new Db{nullptr, nullptr}) {}
+
+ItaniumPartialDemangler::~ItaniumPartialDemangler() {
+  delete static_cast<Db *>(Context);
+}
+
+ItaniumPartialDemangler::ItaniumPartialDemangler(
+    ItaniumPartialDemangler &&Other) {
+  std::swap(RootNode, Other.RootNode);
+  std::swap(Context, Other.Context);
+}
+
+ItaniumPartialDemangler &ItaniumPartialDemangler::
+operator=(ItaniumPartialDemangler &&Other) {
+  std::swap(RootNode, Other.RootNode);
+  std::swap(Context, Other.Context);
+  return *this;
+}
+
+// Demangle MangledName into an AST, storing it into this->RootNode.
+bool ItaniumPartialDemangler::partialDemangle(const char *MangledName) {
+  Db *Parser = static_cast<Db *>(Context);
+  size_t Len = std::strlen(MangledName);
+  Parser->reset(MangledName, MangledName + Len);
+  RootNode = Parser->parse();
+  if (RootNode == nullptr)
+    return true;
+
+  if (Parser->FixForwardReferences && !Parser->TemplateParams.empty()) {
+    Parser->FixForwardReferences = false;
+    Parser->TagTemplates = false;
+    Parser->Names.clear();
+    Parser->Subs.clear();
+    Parser->First = MangledName;
+    Parser->Last = MangledName + Len;
+    RootNode = Parser->parse();
+    if (RootNode == nullptr || Parser->FixForwardReferences)
+      return true;
+  }
+
+  return static_cast<Node *>(RootNode)->containsUnexpandedParameterPack();
+}
+
+static char *printNode(Node *RootNode, char *Buf, size_t *N) {
+  size_t BufSize;
+  if (Buf == nullptr) {
+    Buf = static_cast<char *>(std::malloc(1024));
+    BufSize = 1024;
+    if (Buf == nullptr)
+      return nullptr;
+  } else {
+    BufSize = *N;
+  }
+
+  OutputStream S(Buf, BufSize);
+  RootNode->print(S);
+  S += '\0';
+  if (N != nullptr)
+    *N = S.getCurrentPosition();
+  return S.getBuffer();
+}
+
+static char *printStringView(StringView Str, char *Buf, size_t *N) {
+  if (N == nullptr)
+    Buf = static_cast<char *>(std::malloc(Str.size() + 1));
+  else if (*N < Str.size() + 1) {
+    Buf = static_cast<char *>(std::realloc(Buf, Str.size() + 1));
+    *N = Str.size() + 1;
+  }
+
+  std::copy(Str.begin(), Str.end(), Buf);
+  Buf[Str.size()] = '\0';
+  return Buf;
+}
+
+static Node *findBaseName(Node *Name) {
+  while (true) {
+    switch (Name->getKind()) {
+    case Node::KQualifiedName:
+      Name = static_cast<QualifiedName *>(Name)->Name;
+      break;
+    case Node::KStdQualifiedName:
+      Name = static_cast<StdQualifiedName *>(Name)->Child;
+      break;
+    case Node::KGlobalQualifiedName:
+      Name = static_cast<GlobalQualifiedName *>(Name)->Child;
+      break;
+    case Node::KNameWithTemplateArgs:
+      Name = static_cast<NameWithTemplateArgs *>(Name)->Name;
+      break;
+    case Node::KCtorDtorName:
+      Name = static_cast<CtorDtorName *>(Name)->Basename;
+      break;
+    case Node::KAbiTagAttr:
+      Name = static_cast<AbiTagAttr *>(Name)->Base;
+      break;
+    default:
+      return Name;
+    }
+  }
+}
+
+char *ItaniumPartialDemangler::getFunctionBaseName(char *Buf, size_t *N) const {
+  if (!isFunction())
+    return nullptr;
+
+  Node *Name = findBaseName(
+      static_cast<FunctionEncoding *>(RootNode)->getName());
+
+  switch (Name->getKind()) {
+  case Node::KExpandedSpecialSubstitution:
+  case Node::KSpecialSubstitution: {
+    auto View = Name->getBaseName();
+    if (N == nullptr)
+      Buf = static_cast<char *>(std::malloc(View.size() + 1));
+    else if (*N < View.size() + 1)
+      Buf = static_cast<char *>(std::realloc(Buf, View.size() + 1));
+    std::copy(View.begin(), View.end(), Buf);
+    Buf[View.size()] = '\0';
+    return Buf;
+  }
+  default:
+    break;
+  }
+
+  return printNode(Name, Buf, N);
+}
+
+char *ItaniumPartialDemangler::getFunctionContextName(char *Buf,
+                                                      size_t *N) const {
+  if (!isFunction())
+    return nullptr;
+  Node *Name = static_cast<FunctionEncoding *>(RootNode)->getName();
+  while (true) {
+    switch (Name->getKind()) {
+    case Node::KQualifiedName:
+      Name = static_cast<QualifiedName *>(Name)->Qualifier;
+      return printNode(Name, Buf, N);
+    case Node::KStdQualifiedName:
+      return printStringView("std", Buf, N);
+    case Node::KNameWithTemplateArgs:
+      Name = static_cast<NameWithTemplateArgs *>(Name)->Name;
+      break;
+    case Node::KCtorDtorName:
+      Name = static_cast<CtorDtorName *>(Name)->Basename;
+      return printNode(Name, Buf, N);
+    case Node::KAbiTagAttr:
+      Name = static_cast<AbiTagAttr *>(Name)->Base;
+      break;
+    default:
+      return nullptr;
+    }
+  }
+}
+
+char *ItaniumPartialDemangler::getFunctionName(char *Buf, size_t *N) const {
+  if (!isFunction())
+    return nullptr;
+  auto *Enc = static_cast<FunctionEncoding *>(RootNode)->getName();
+  return printNode(Enc, Buf, N);
+}
+
+char *ItaniumPartialDemangler::getFunctionParameters(char *Buf,
+                                                     size_t *N) const {
+  if (!isFunction())
+    return nullptr;
+  auto Params = static_cast<FunctionEncoding *>(RootNode)->getParams();
+
+  size_t Size;
+  if (N == nullptr) {
+    Size = 128;
+    Buf = static_cast<char *>(std::malloc(Size));
+  } else
+    Size = *N;
+
+
+  OutputStream Stream(Buf, Size);
+  Stream += '(';
+  Params.printWithComma(Stream);
+  Stream += ')';
+  Stream += '\0';
+
+  if (N != nullptr)
+    *N = Stream.getCurrentPosition();
+  return Stream.getBuffer();
+}
+
+char *ItaniumPartialDemangler::finishDemangle(char *Buf, size_t *N) const {
+  assert(RootNode != nullptr && "must call partialDemangle()");
+  return printNode(static_cast<Node *>(RootNode), Buf, N);
+}
+
+bool ItaniumPartialDemangler::isProvablyMemberFunction() const {
+  assert(RootNode != nullptr && "must call partialDemangle()");
+  if (!isFunction())
+    return false;
+  auto *E = static_cast<FunctionEncoding *>(RootNode);
+  return E->getCVQuals() != QualNone || E->getRefQual() != FrefQualNone;
+}
+
+bool ItaniumPartialDemangler::isFunction() const {
+  assert(RootNode != nullptr && "must call partialDemangle()");
+  return static_cast<Node *>(RootNode)->getKind() == Node::KFunctionEncoding;
+}
+
+bool ItaniumPartialDemangler::isSpecialName() const {
+  assert(RootNode != nullptr && "must call partialDemangle()");
+  auto K = static_cast<Node *>(RootNode)->getKind();
+  return K == Node::KSpecialName || K == Node::KCtorVtableSpecialName;
+}
+
+}

llvm/unittests/CMakeLists.txt

 add_custom_target(UnitTests)
 set_target_properties(UnitTests PROPERTIES FOLDER "Tests")
 
 function(add_llvm_unittest test_dirname)
   add_unittest(UnitTests ${test_dirname} ${ARGN})
 endfunction()
 
 add_subdirectory(ADT)
 add_subdirectory(Analysis)
 add_subdirectory(AsmParser)
 add_subdirectory(Bitcode)
 add_subdirectory(CodeGen)
 add_subdirectory(DebugInfo)
+add_subdirectory(Demangle)
 add_subdirectory(ExecutionEngine)
 add_subdirectory(FuzzMutate)
 add_subdirectory(IR)
 add_subdirectory(LineEditor)
 add_subdirectory(Linker)
 add_subdirectory(MC)
 add_subdirectory(MI)
 add_subdirectory(Object)

llvm/unittests/Demangle/CMakeLists.txt

+set(DemangleSources
+  PartialDemangleTest.cpp
+)
+
+add_llvm_unittest(DemangleTests
+  ${DemangleSources}
+)

llvm/unittests/Demangle/PartialDemangleTest.cpp

+//===----------------------- PartialDemangleTest.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.
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm/Demangle/Demangle.h"
+#include "gtest/gtest.h"
+
+TEST(PartialDemangleTest, TestNameSplitting) {
+  llvm::ItaniumPartialDemangler Context;
+  EXPECT_FALSE(Context.partialDemangle("_Z1fv"));
+
+  size_t Size = 4;
+  char *Buffer = static_cast<char *>(std::malloc(Size));
+
+  Buffer = Context.getFunctionBaseName(Buffer, &Size);
+  EXPECT_EQ(strcmp(Buffer, "f"), 0);
+
+  Buffer = Context.getFunctionParameters(Buffer, &Size);
+  EXPECT_EQ(strcmp(Buffer, "()"), 0);
+
+  Buffer = Context.getFunctionName(Buffer, &Size);
+  EXPECT_EQ(strcmp(Buffer, "f"), 0);
+
+  EXPECT_FALSE(Context.partialDemangle("_ZN1a1b1cIiiiEEvm"));
+
+  Buffer = Context.getFunctionBaseName(Buffer, &Size);
+  EXPECT_EQ(strcmp(Buffer, "c"), 0);
+
+  Buffer = Context.getFunctionContextName(Buffer, &Size);
+  EXPECT_EQ(strcmp(Buffer, "a::b"), 0);
+
+  Buffer = Context.getFunctionName(Buffer, &Size);
+  EXPECT_EQ(strcmp(Buffer, "a::b::c<int, int, int>"), 0);
+
+  Buffer = Context.getFunctionParameters(Buffer, &Size);
+  EXPECT_EQ(strcmp(Buffer, "(unsigned long)"), 0);
+
+  Buffer = Context.finishDemangle(Buffer, &Size);
+  EXPECT_EQ(strcmp(Buffer, "void a::b::c<int, int, int>(unsigned long)"), 0);
+
+  EXPECT_FALSE(Context.isProvablyMemberFunction());
+  EXPECT_TRUE(Context.isFunction());
+  EXPECT_FALSE(Context.isSpecialName());
+
+  std::free(Buffer);
+}