[demangler] Add operator precedence

[urnathan]

Summary

The demangler had no concept of operator precendence, and would parenthesize many more subexpressions than necessary. In particular it would parenthesize primary-expressions, such as '4', which just looks strange. It would also parenthesize '>' expressions, just in case they were inside a template parameter list.

This patch fixes both issues.

• Add operator precedence to the OpInfo structure, and add a subexpression helper that will parenthesize a lower precedence subexpression.

• Add a 'greater-than is greater-than' indicator to the output buffer, so the expression printer knows whether it is immediately inside a template parameter list (and must therefore parenthesize 'expr > expr'). This is a counter, so that ...

• Add open and close printers to the output buffer, that increment and decrement the gt-is-gt indicator.

• Parenthesize comma operators inside comma-separated lists. (probably a rare case, but still).

This dramatically reduces the extraneous parentheses being printed.

[bruno]

Nice cleanup, fixes and testcases, just pending test failures and this looks good.

libcxxabi/src/demangle/ItaniumDemangle.h

281

Nice!

[urnathan]

remove C++14 auto use -- thought I'd already done that :(

[urnathan]

sigh, a test case change had got attached to the wrong local commit. this time for sure!

[urnathan]

Rebased. I believe the bruno-requested changes are done.

[dblaikie]

Looks like the buildbot failures include two timeouts, and a format check that's already failing, perhaps? If that's it, then seems OK to me.

[urnathan]

In D120905#3403253, @dblaikie wrote:

Looks like the buildbot failures include two timeouts, and a format check that's already failing, perhaps? If that's it, then seems OK to me.

Yes, the format failure is because the entire test program is badly formatted, and mostly contained in one many-thousand-line array, which any new mangling test adds elements too. And hence the formatter reformats the entire array. (and reformatting the array is (a) unwanted and (b) blows up the diff limit of phabricator)

[dblaikie]

In D120905#3404948, @urnathan wrote:

In D120905#3403253, @dblaikie wrote:

Looks like the buildbot failures include two timeouts, and a format check that's already failing, perhaps? If that's it, then seems OK to me.

Yes, the format failure is because the entire test program is badly formatted, and mostly contained in one many-thousand-line array, which any new mangling test adds elements too. And hence the formatter reformats the entire array. (and reformatting the array is (a) unwanted and (b) blows up the diff limit of phabricator)

Yeah - if you like, it's probably fine to reformat that and commit it directly without review before or after this patch. But no big deal either way.

[rjmccall]

libcxxabi/src/demangle/ItaniumDemangle.h

1788

Does this not need to apply to >> for some reason, or does demangling just have a longstanding bug?

[urnathan]

libcxxabi/src/demangle/ItaniumDemangle.h

1788

you remind me that I puzzled about this, it is indeed a long-standing bug that we can deal with in a followup?

pre-patch we special cased ">" in an equivalent manner to here, but not ">>":

// might be a template argument expression, then we need to disambiguate
// with parens.
if (InfixOperator == ">")
  OB += "(";

I guess that predates C++'s splitting of >> in template arg parsing?

[bruno]

LGTM

[goncharov]

llvm/include/llvm/Demangle/ItaniumDemangle.h

1785

I am not familiar with the code at all, but it seems to be an issue. We have downstream code that relies on the ability to match mode from ctor, but this "match" and other definitions have not been updated along with ctors. Do you mind reverting the patch for now?

[ldionne]

llvm/include/llvm/Demangle/ItaniumDemangle.h

1785

Can you give a bit more context regarding what issue you're encountering? Since this was landed some time ago, I think it would be best to fix-forward if we can.

[frgossen]

llvm/include/llvm/Demangle/ItaniumDemangle.h

1785

We have a use of match that expects to invoke the constructor with the arguments it's being passed. That use is missing the precedence argument now, which is not being passed here but it is required for the constructor above.

I am not sure if this is a false use of match or if the match function should deal with the prec argument also.

[urnathan]

• 0001-WIP-match.patch13 KBDownload

[dblaikie]

In D120905#3412571, @urnathan wrote:

• 0001-WIP-match.patch13 KBDownload

Ah, thanks for posting - I committed an incomplete fix (didn't touch all the other ctors) in 1d1cf9b6c42c820f38eb776cb7504564441a23ee - I think the right thing is probably to do-nothing in print(Node::Prec prec) - since I assume/my understanding is that the printing already accounts for precedence by adding parentheses etc where needed?

llvm/include/llvm/Demangle/ItaniumDemangle.h

1785

4 hours isn't an especially large window for a revert, but yeah - some more context would be good. I'm working on providing that now/too.

But, yeah, it looks like, judging by other "match" functions it should have the same arg list as the ctor.

[dblaikie]

In D120905#3412586, @dblaikie wrote:

In D120905#3412571, @urnathan wrote:

• 0001-WIP-match.patch13 KBDownload

Ah, thanks for posting - I committed an incomplete fix (didn't touch all the other ctors) in 1d1cf9b6c42c820f38eb776cb7504564441a23ee - I think the right thing is probably to do-nothing in print(Node::Prec prec) - since I assume/my understanding is that the printing already accounts for precedence by adding parentheses etc where needed?

In any case, @urnathan - could you go ahead and commit the rest of the match fixes (& maybe for now leave my no-op version of print(Prec) in place - happy to discuss further what that should/shouldn't do here before we make further changes)? Or I can if you like.

[urnathan]

In D120905#3412594, @dblaikie wrote:

In D120905#3412586, @dblaikie wrote:

In D120905#3412571, @urnathan wrote:

• 0001-WIP-match.patch13 KBDownload

Ah, thanks for posting - I committed an incomplete fix (didn't touch all the other ctors) in 1d1cf9b6c42c820f38eb776cb7504564441a23ee - I think the right thing is probably to do-nothing in print(Node::Prec prec) - since I assume/my understanding is that the printing already accounts for precedence by adding parentheses etc where needed?

In any case, @urnathan - could you go ahead and commit the rest of the match fixes (& maybe for now leave my no-op version of print(Prec) in place - happy to discuss further what that should/shouldn't do here before we make further changes)? Or I can if you like.

I have pushed:

c204cee642ee 2022-03-29 | [demangler] Update node match calls

to address the missing ctor args in the match functions. The Visitor print call you mention, and a variant in cxa_demangle.cpp's NDEBUG code (it is sad there's more duplication), should print the name of the enumerator -- these are visitors for dumping a textual representation of the node graph.

I'll post a patch to do that, along with a testcase exercising this piece of machinery, for review.

[frgossen]

I see parenthesis around simple types like int. Not sure if this is intended.

[urnathan]

In D120905#3414455, @frgossen wrote:

I see parenthesis around simple types like int. Not sure if this is intended.

do you mean things like '(int)1' --that's a cast (and I remember being tripped up by that. If it's something else can you provide a testcase?

[frgossen]

It's wrapping the function args. I think it's just the space that confused me. Here's the example for completeness.

std::enable_if<sizeof (int) == 4, int>::type func<int>

[urnathan]

In D120905#3414555, @frgossen wrote:

It's wrapping the function args. I think it's just the space that confused me. Here's the example for completeness.

std::enable_if<sizeof (int) == 4, int>::type func<int>

erm, there are no function args in that example? But the enable_if template arg list looks syntactically correct to me. I've not changed the space in 'sizeof[SPC]([expr|type]) (or typeid/noexcep/alignof)

[dblaikie]

In D120905#3413721, @urnathan wrote:

In D120905#3412594, @dblaikie wrote:

In D120905#3412586, @dblaikie wrote:

In D120905#3412571, @urnathan wrote:

• 0001-WIP-match.patch13 KBDownload

Ah, thanks for posting - I committed an incomplete fix (didn't touch all the other ctors) in 1d1cf9b6c42c820f38eb776cb7504564441a23ee - I think the right thing is probably to do-nothing in print(Node::Prec prec) - since I assume/my understanding is that the printing already accounts for precedence by adding parentheses etc where needed?

In any case, @urnathan - could you go ahead and commit the rest of the match fixes (& maybe for now leave my no-op version of print(Prec) in place - happy to discuss further what that should/shouldn't do here before we make further changes)? Or I can if you like.

I have pushed:

c204cee642ee 2022-03-29 | [demangler] Update node match calls

to address the missing ctor args in the match functions. The Visitor print call you mention, and a variant in cxa_demangle.cpp's NDEBUG code (it is sad there's more duplication), should print the name of the enumerator -- these are visitors for dumping a textual representation of the node graph.

I'll post a patch to do that, along with a testcase exercising this piece of machinery, for review.

awesome, thanks!

libcxxabi/src/demangle/ItaniumDemangle.h

#define ENUMERATOR(NodeKind) K ## NodeKind,
     FOR_EACH_NODE_KIND(ENUMERATOR)
 #undef ENUMERATOR
   };
 
   /// Three-way bool to track a cached value. Unknown is possible if this node
   /// has an unexpanded parameter pack below it that may affect this cache.
   enum class Cache : unsigned char { Yes, No, Unknown, };
 
+  /// Operator precedence for expression nodes. Used to determine required
+  /// parens in expression emission.
+  enum class Prec {
+    Primary,
+    Postfix,
+    Unary,
+    Cast,
+    PtrMem,
+    Multiplicative,
+    Additive,
+    Shift,
+    Spaceship,
+    Relational,
+    Equality,
+    And,
+    Xor,
+    Ior,
+    AndIf,
+    OrIf,
+    Conditional,
+    Assign,
+    Comma,
+    Default,
+  };
+
 private:
   Kind K;
 
+  Prec Precedence : 6;
+
   // FIXME: Make these protected.
 public:
   /// Tracks if this node has a component on its right side, in which case we
   /// need to call printRight.
-  Cache RHSComponentCache;
+  Cache RHSComponentCache : 2;
 
   /// Track if this node is a (possibly qualified) array type. This can affect
   /// how we format the output string.
-  Cache ArrayCache;
+  Cache ArrayCache : 2;
 
   /// Track if this node is a (possibly qualified) function type. This can
   /// affect how we format the output string.
-  Cache FunctionCache;
+  Cache FunctionCache : 2;
 
 public:
-  Node(Kind K_, Cache RHSComponentCache_ = Cache::No,
-       Cache ArrayCache_ = Cache::No, Cache FunctionCache_ = Cache::No)
-      : K(K_), RHSComponentCache(RHSComponentCache_), ArrayCache(ArrayCache_),
-        FunctionCache(FunctionCache_) {}
+  Node(Kind K_, Prec Precedence_ = Prec::Primary,
+       Cache RHSComponentCache_ = Cache::No, Cache ArrayCache_ = Cache::No,
+       Cache FunctionCache_ = Cache::No)
+      : K(K_), Precedence(Precedence_), RHSComponentCache(RHSComponentCache_),
+        ArrayCache(ArrayCache_), FunctionCache(FunctionCache_) {}
+  Node(Kind K_, Cache RHSComponentCache_, Cache ArrayCache_ = Cache::No,
+       Cache FunctionCache_ = Cache::No)
+      : Node(K_, Prec::Primary, RHSComponentCache_, ArrayCache_,
+             FunctionCache_) {}
 
   /// Visit the most-derived object corresponding to this object.
   template<typename Fn> void visit(Fn F) const;
 
   // The following function is provided by all derived classes:
   //
   // Call F with arguments that, when passed to the constructor of this node,
   // would construct an equivalent node.
public:
   bool hasFunction(OutputBuffer &OB) const {
     if (FunctionCache != Cache::Unknown)
       return FunctionCache == Cache::Yes;
     return hasFunctionSlow(OB);
   }
 
   Kind getKind() const { return K; }
 
+  Prec getPrecedence() const { return Precedence; }
+
   virtual bool hasRHSComponentSlow(OutputBuffer &) const { return false; }
   virtual bool hasArraySlow(OutputBuffer &) const { return false; }
   virtual bool hasFunctionSlow(OutputBuffer &) const { return false; }
 
   // Dig through "glue" nodes like ParameterPack and ForwardTemplateReference to
   // get at a node that actually represents some concrete syntax.
   virtual const Node *getSyntaxNode(OutputBuffer &) const { return this; }
 
+  // Print this node as an expression operand, surrounding it in parentheses if
+  // its precedence is [Strictly] weaker than P.
+  void printAsOperand(OutputBuffer &OB, Prec P = Prec::Default,
+                      bool StrictlyWorse = false) const {
+    bool Paren =
+        unsigned(getPrecedence()) >= unsigned(P) + unsigned(StrictlyWorse);
+    if (Paren)
+      OB.printOpen();
+    print(OB);
+    if (Paren)
+      OB.printClose();
+  }
+
   void print(OutputBuffer &OB) const {
     printLeft(OB);
     if (RHSComponentCache != Cache::No)
       printRight(OB);
   }
 
   // Print the "left" side of this Node into OutputBuffer.
   virtual void printLeft(OutputBuffer &) const = 0;
public:
 
   void printWithComma(OutputBuffer &OB) const {
     bool FirstElement = true;
     for (size_t Idx = 0; Idx != NumElements; ++Idx) {
       size_t BeforeComma = OB.getCurrentPosition();
       if (!FirstElement)
         OB += ", ";
       size_t AfterComma = OB.getCurrentPosition();
-      Elements[Idx]->print(OB);
+      Elements[Idx]->printAsOperand(OB, Node::Prec::Comma);
 
       // Elements[Idx] is an empty parameter pack expansion, we should erase the
       // comma we just printed.
       if (AfterComma == OB.getCurrentPosition()) {
         OB.setCurrentPosition(BeforeComma);
         continue;
       }
 
public:
   // by printing out the return types's left, then print our parameters, then
   // finally print right of the return type.
   void printLeft(OutputBuffer &OB) const override {
     Ret->printLeft(OB);
     OB += " ";
   }
 
   void printRight(OutputBuffer &OB) const override {
-    OB += "(";
+    OB.printOpen();
     Params.printWithComma(OB);
-    OB += ")";
+    OB.printClose();
     Ret->printRight(OB);
 
     if (CVQuals & QualConst)
       OB += " const";
     if (CVQuals & QualVolatile)
       OB += " volatile";
     if (CVQuals & QualRestrict)
       OB += " restrict";

 class NoexceptSpec : public Node {
   const Node *E;
 public:
   NoexceptSpec(const Node *E_) : Node(KNoexceptSpec), E(E_) {}
 
   template<typename Fn> void match(Fn F) const { F(E); }
 
   void printLeft(OutputBuffer &OB) const override {
-    OB += "noexcept(";
-    E->print(OB);
-    OB += ")";
+    OB += "noexcept";
+    OB.printOpen();
+    E->printAsOperand(OB);
+    OB.printClose();
   }
 };
 
 class DynamicExceptionSpec : public Node {
   NodeArray Types;
 public:
   DynamicExceptionSpec(NodeArray Types_)
       : Node(KDynamicExceptionSpec), Types(Types_) {}
 
   template<typename Fn> void match(Fn F) const { F(Types); }
 
   void printLeft(OutputBuffer &OB) const override {
-    OB += "throw(";
+    OB += "throw";
+    OB.printOpen();
     Types.printWithComma(OB);
-    OB += ')';
+    OB.printClose();
   }
 };
 
 class FunctionEncoding final : public Node {
   const Node *Ret;
   const Node *Name;
   NodeArray Params;
   const Node *Attrs;
if (Ret) {
       Ret->printLeft(OB);
       if (!Ret->hasRHSComponent(OB))
         OB += " ";
     }
     Name->print(OB);
   }
 
   void printRight(OutputBuffer &OB) const override {
-    OB += "(";
+    OB.printOpen();
     Params.printWithComma(OB);
-    OB += ")";
+    OB.printClose();
     if (Ret)
       Ret->printRight(OB);
 
     if (CVQuals & QualConst)
       OB += " const";
     if (CVQuals & QualVolatile)
       OB += " volatile";
     if (CVQuals & QualRestrict)

 public:
   TemplateTemplateParamDecl(Node *Name_, NodeArray Params_)
       : Node(KTemplateTemplateParamDecl, Cache::Yes), Name(Name_),
         Params(Params_) {}
 
   template<typename Fn> void match(Fn F) const { F(Name, Params); }
 
   void printLeft(OutputBuffer &OB) const override {
+    SwapAndRestore<unsigned> LT(OB.GtIsGt, 0);
     OB += "template<";
     Params.printWithComma(OB);
     OB += "> typename ";
   }
 
   void printRight(OutputBuffer &OB) const override { Name->print(OB); }
 };
 

 public:
   TemplateArgs(NodeArray Params_) : Node(KTemplateArgs), Params(Params_) {}
 
   template<typename Fn> void match(Fn F) const { F(Params); }
 
   NodeArray getParams() { return Params; }
 
   void printLeft(OutputBuffer &OB) const override {
+    SwapAndRestore<unsigned> LT(OB.GtIsGt, 0);
     OB += "<";
     Params.printWithComma(OB);
     if (OB.back() == '>')
       OB += " ";
     OB += ">";
   }
 };
 
ClosureTypeName(NodeArray TemplateParams_, NodeArray Params_,
         Params(Params_), Count(Count_) {}
 
   template<typename Fn> void match(Fn F) const {
     F(TemplateParams, Params, Count);
   }
 
   void printDeclarator(OutputBuffer &OB) const {
     if (!TemplateParams.empty()) {
+      SwapAndRestore<unsigned> LT(OB.GtIsGt, 0);
       OB += "<";
       TemplateParams.printWithComma(OB);
       OB += ">";
     }
-    OB += "(";
+    OB.printOpen();
     Params.printWithComma(OB);
-    OB += ")";
+    OB.printClose();
   }
 
   void printLeft(OutputBuffer &OB) const override {
     OB += "\'lambda";
     OB += Count;
     OB += "\'";
     printDeclarator(OB);
   }
 };
 
 class StructuredBindingName : public Node {
   NodeArray Bindings;
 public:
   StructuredBindingName(NodeArray Bindings_)
       : Node(KStructuredBindingName), Bindings(Bindings_) {}
 
   template<typename Fn> void match(Fn F) const { F(Bindings); }
 
   void printLeft(OutputBuffer &OB) const override {
-    OB += '[';
+    OB.printOpen('[');
     Bindings.printWithComma(OB);
-    OB += ']';
+    OB.printClose(']');
   }
 };
 
 // -- Expression Nodes --
 
 class BinaryExpr : public Node {
   const Node *LHS;
   const StringView InfixOperator;
   const Node *RHS;
 
 public:
-  BinaryExpr(const Node *LHS_, StringView InfixOperator_, const Node *RHS_)
-      : Node(KBinaryExpr), LHS(LHS_), InfixOperator(InfixOperator_), RHS(RHS_) {
-  }
+  BinaryExpr(const Node *LHS_, StringView InfixOperator_, const Node *RHS_,
+             Prec Prec_)
+      : Node(KBinaryExpr, Prec_), LHS(LHS_), InfixOperator(InfixOperator_),
+        RHS(RHS_) {}
 
   template<typename Fn> void match(Fn F) const { F(LHS, InfixOperator, RHS); }
 
   void printLeft(OutputBuffer &OB) const override {
-    // might be a template argument expression, then we need to disambiguate
-    // with parens.
-    if (InfixOperator == ">")
-      OB += "(";
-
-    OB += "(";
-    LHS->print(OB);
-    OB += ") ";
+    bool ParenAll = OB.isGtInsideTemplateArgs() && InfixOperator == ">";
+    if (ParenAll)
+      OB.printOpen();
+    // Assignment is right associative, with special LHS precedence.
+    bool IsAssign = getPrecedence() == Prec::Assign;
+    LHS->printAsOperand(OB, IsAssign ? Prec::OrIf : getPrecedence(), !IsAssign);
+    // No space before comma operator
+    if (!(InfixOperator == ","))
+      OB += " ";
     OB += InfixOperator;
-    OB += " (";
-    RHS->print(OB);
-    OB += ")";
-
-    if (InfixOperator == ">")
-      OB += ")";
+    OB += " ";
+    RHS->printAsOperand(OB, getPrecedence(), IsAssign);
+    if (ParenAll)
+      OB.printClose();
   }
 };
 
 class ArraySubscriptExpr : public Node {
   const Node *Op1;
   const Node *Op2;
 
 public:
-  ArraySubscriptExpr(const Node *Op1_, const Node *Op2_)
-      : Node(KArraySubscriptExpr), Op1(Op1_), Op2(Op2_) {}
+  ArraySubscriptExpr(const Node *Op1_, const Node *Op2_, Prec Prec_)
+      : Node(KArraySubscriptExpr, Prec_), Op1(Op1_), Op2(Op2_) {}
 
   template<typename Fn> void match(Fn F) const { F(Op1, Op2); }
 
   void printLeft(OutputBuffer &OB) const override {
-    OB += "(";
-    Op1->print(OB);
-    OB += ")[";
-    Op2->print(OB);
-    OB += "]";
+    Op1->printAsOperand(OB, getPrecedence());
+    OB.printOpen('[');
+    Op2->printAsOperand(OB);
+    OB.printClose(']');
   }
 };
 
 class PostfixExpr : public Node {
   const Node *Child;
   const StringView Operator;
 
 public:
-  PostfixExpr(const Node *Child_, StringView Operator_)
-      : Node(KPostfixExpr), Child(Child_), Operator(Operator_) {}
+  PostfixExpr(const Node *Child_, StringView Operator_, Prec Prec_)
+      : Node(KPostfixExpr, Prec_), Child(Child_), Operator(Operator_) {}
 
   template<typename Fn> void match(Fn F) const { F(Child, Operator); }
 
   void printLeft(OutputBuffer &OB) const override {
-    OB += "(";
-    Child->print(OB);
-    OB += ")";
+    Child->printAsOperand(OB, getPrecedence(), true);
     OB += Operator;
   }
 };
 
 class ConditionalExpr : public Node {
   const Node *Cond;
   const Node *Then;
   const Node *Else;
 
 public:
-  ConditionalExpr(const Node *Cond_, const Node *Then_, const Node *Else_)
-      : Node(KConditionalExpr), Cond(Cond_), Then(Then_), Else(Else_) {}
+  ConditionalExpr(const Node *Cond_, const Node *Then_, const Node *Else_,
+                  Prec Prec_)
+      : Node(KConditionalExpr, Prec_), Cond(Cond_), Then(Then_), Else(Else_) {}
 
   template<typename Fn> void match(Fn F) const { F(Cond, Then, Else); }
 
   void printLeft(OutputBuffer &OB) const override {
-    OB += "(";
-    Cond->print(OB);
-    OB += ") ? (";
-    Then->print(OB);
-    OB += ") : (";
-    Else->print(OB);
-    OB += ")";
+    Cond->printAsOperand(OB, getPrecedence());
+    OB += " ? ";
+    Then->printAsOperand(OB);
+    OB += " : ";
+    Else->printAsOperand(OB, Prec::Assign, true);
   }
 };
 
 class MemberExpr : public Node {
   const Node *LHS;
   const StringView Kind;
   const Node *RHS;
 
 public:
-  MemberExpr(const Node *LHS_, StringView Kind_, const Node *RHS_)
-      : Node(KMemberExpr), LHS(LHS_), Kind(Kind_), RHS(RHS_) {}
+  MemberExpr(const Node *LHS_, StringView Kind_, const Node *RHS_, Prec Prec_)
+      : Node(KMemberExpr, Prec_), LHS(LHS_), Kind(Kind_), RHS(RHS_) {}
 
   template<typename Fn> void match(Fn F) const { F(LHS, Kind, RHS); }
 
   void printLeft(OutputBuffer &OB) const override {
-    LHS->print(OB);
+    LHS->printAsOperand(OB, getPrecedence(), true);
     OB += Kind;
-    // Parenthesize pointer-to-member deference argument.
-    bool IsPtr = Kind.back() == '*';
-    if (IsPtr)
-      OB += '(';
-    RHS->print(OB);
-    if (IsPtr)
-      OB += ')';
+    RHS->printAsOperand(OB, getPrecedence(), false);
   }
 };
 
 class SubobjectExpr : public Node {
   const Node *Type;
   const Node *SubExpr;
   StringView Offset;
   NodeArray UnionSelectors;

 };
 
 class EnclosingExpr : public Node {
   const StringView Prefix;
   const Node *Infix;
   const StringView Postfix;
 
 public:
-  EnclosingExpr(StringView Prefix_, Node *Infix_, StringView Postfix_)
-      : Node(KEnclosingExpr), Prefix(Prefix_), Infix(Infix_),
-        Postfix(Postfix_) {}
+  EnclosingExpr(StringView Prefix_, Node *Infix_, Prec Prec_ = Prec::Primary)
+      : Node(KEnclosingExpr, Prec_), Prefix(Prefix_), Infix(Infix_) {}
 
-  template<typename Fn> void match(Fn F) const { F(Prefix, Infix, Postfix); }
+  template <typename Fn> void match(Fn F) const { F(Prefix, Infix); }
 
   void printLeft(OutputBuffer &OB) const override {
     OB += Prefix;
+    OB.printOpen();
     Infix->print(OB);
+    OB.printClose();
     OB += Postfix;
   }
 };
 
 class CastExpr : public Node {
   // cast_kind<to>(from)
   const StringView CastKind;
   const Node *To;
   const Node *From;
 
 public:
-  CastExpr(StringView CastKind_, const Node *To_, const Node *From_)
-      : Node(KCastExpr), CastKind(CastKind_), To(To_), From(From_) {}
+  CastExpr(StringView CastKind_, const Node *To_, const Node *From_, Prec Prec_)
+      : Node(KCastExpr, Prec_), CastKind(CastKind_), To(To_), From(From_) {}
 
   template<typename Fn> void match(Fn F) const { F(CastKind, To, From); }
 
   void printLeft(OutputBuffer &OB) const override {
     OB += CastKind;
+    {
+      SwapAndRestore<unsigned> LT(OB.GtIsGt, 0);
       OB += "<";
       To->printLeft(OB);
-    OB += ">(";
-    From->printLeft(OB);
-    OB += ")";
+      if (OB.back() == '>')
+        OB += " ";
+      OB += ">";
+    }
+    OB.printOpen();
+    From->printAsOperand(OB);
+    OB.printClose();
   }
 };
 
 class SizeofParamPackExpr : public Node {
   const Node *Pack;
 
 public:
   SizeofParamPackExpr(const Node *Pack_)
       : Node(KSizeofParamPackExpr), Pack(Pack_) {}
 
   template<typename Fn> void match(Fn F) const { F(Pack); }
 
   void printLeft(OutputBuffer &OB) const override {
-    OB += "sizeof...(";
+    OB += "sizeof...";
+    OB.printOpen();
     ParameterPackExpansion PPE(Pack);
     PPE.printLeft(OB);
-    OB += ")";
+    OB.printClose();
   }
 };
 
 class CallExpr : public Node {
   const Node *Callee;
   NodeArray Args;
 
 public:
-  CallExpr(const Node *Callee_, NodeArray Args_)
-      : Node(KCallExpr), Callee(Callee_), Args(Args_) {}
+  CallExpr(const Node *Callee_, NodeArray Args_, Prec Prec_)
+      : Node(KCallExpr, Prec_), Callee(Callee_), Args(Args_) {}
 
   template<typename Fn> void match(Fn F) const { F(Callee, Args); }
 
   void printLeft(OutputBuffer &OB) const override {
     Callee->print(OB);
-    OB += "(";
+    OB.printOpen();
     Args.printWithComma(OB);
-    OB += ")";
+    OB.printClose();
   }
 };
 
 class NewExpr : public Node {
   // new (expr_list) type(init_list)
   NodeArray ExprList;
   Node *Type;
   NodeArray InitList;
   bool IsGlobal; // ::operator new ?
   bool IsArray;  // new[] ?
 public:
   NewExpr(NodeArray ExprList_, Node *Type_, NodeArray InitList_, bool IsGlobal_,
-          bool IsArray_)
-      : Node(KNewExpr), ExprList(ExprList_), Type(Type_), InitList(InitList_),
-        IsGlobal(IsGlobal_), IsArray(IsArray_) {}
+          bool IsArray_, Prec Prec_)
+      : Node(KNewExpr, Prec_), ExprList(ExprList_), Type(Type_),
+        InitList(InitList_), IsGlobal(IsGlobal_), IsArray(IsArray_) {}
 
   template<typename Fn> void match(Fn F) const {
     F(ExprList, Type, InitList, IsGlobal, IsArray);
   }
 
   void printLeft(OutputBuffer &OB) const override {
     if (IsGlobal)
       OB += "::";
     OB += "new";
     if (IsArray)
       OB += "[]";
     if (!ExprList.empty()) {
-      OB += "(";
+      OB.printOpen();
       ExprList.printWithComma(OB);
-      OB += ")";
+      OB.printClose();
     }
-    OB += ' ';
+    OB += " ";
     Type->print(OB);
     if (!InitList.empty()) {
-      OB += "(";
+      OB.printOpen();
       InitList.printWithComma(OB);
-      OB += ")";
+      OB.printClose();
     }
   }
 };
 
 class DeleteExpr : public Node {
   Node *Op;
   bool IsGlobal;
   bool IsArray;
 
 public:
-  DeleteExpr(Node *Op_, bool IsGlobal_, bool IsArray_)
-      : Node(KDeleteExpr), Op(Op_), IsGlobal(IsGlobal_), IsArray(IsArray_) {}
+  DeleteExpr(Node *Op_, bool IsGlobal_, bool IsArray_, Prec Prec_)
+      : Node(KDeleteExpr, Prec_), Op(Op_), IsGlobal(IsGlobal_),
+        IsArray(IsArray_) {}
 
   template<typename Fn> void match(Fn F) const { F(Op, IsGlobal, IsArray); }
 
   void printLeft(OutputBuffer &OB) const override {
     if (IsGlobal)
       OB += "::";
     OB += "delete";
     if (IsArray)
       OB += "[]";
     OB += ' ';
     Op->print(OB);
   }
 };
 
 class PrefixExpr : public Node {
   StringView Prefix;
   Node *Child;
 
 public:
-  PrefixExpr(StringView Prefix_, Node *Child_)
-      : Node(KPrefixExpr), Prefix(Prefix_), Child(Child_) {}
+  PrefixExpr(StringView Prefix_, Node *Child_, Prec Prec_)
+      : Node(KPrefixExpr, Prec_), Prefix(Prefix_), Child(Child_) {}
 
   template<typename Fn> void match(Fn F) const { F(Prefix, Child); }
 
   void printLeft(OutputBuffer &OB) const override {
     OB += Prefix;
-    OB += "(";
-    Child->print(OB);
-    OB += ")";
+    Child->printAsOperand(OB, getPrecedence());
   }
 };
 
 class FunctionParam : public Node {
   StringView Number;
 
 public:
   FunctionParam(StringView Number_) : Node(KFunctionParam), Number(Number_) {}
 
   template<typename Fn> void match(Fn F) const { F(Number); }
 
   void printLeft(OutputBuffer &OB) const override {
     OB += "fp";
     OB += Number;
   }
 };
 
 class ConversionExpr : public Node {
   const Node *Type;
   NodeArray Expressions;
 
 public:
-  ConversionExpr(const Node *Type_, NodeArray Expressions_)
-      : Node(KConversionExpr), Type(Type_), Expressions(Expressions_) {}
+  ConversionExpr(const Node *Type_, NodeArray Expressions_, Prec Prec_)
+      : Node(KConversionExpr, Prec_), Type(Type_), Expressions(Expressions_) {}
 
   template<typename Fn> void match(Fn F) const { F(Type, Expressions); }
 
   void printLeft(OutputBuffer &OB) const override {
-    OB += "(";
+    OB.printOpen();
     Type->print(OB);
-    OB += ")(";
+    OB.printClose();
+    OB.printOpen();
     Expressions.printWithComma(OB);
-    OB += ")";
+    OB.printClose();
   }
 };
 
 class PointerToMemberConversionExpr : public Node {
   const Node *Type;
   const Node *SubExpr;
   StringView Offset;
 
 public:
   PointerToMemberConversionExpr(const Node *Type_, const Node *SubExpr_,
-                                StringView Offset_)
-      : Node(KPointerToMemberConversionExpr), Type(Type_), SubExpr(SubExpr_),
-        Offset(Offset_) {}
+                                StringView Offset_, Prec Prec_)
+      : Node(KPointerToMemberConversionExpr, Prec_), Type(Type_),
+        SubExpr(SubExpr_), Offset(Offset_) {}
 
   template<typename Fn> void match(Fn F) const { F(Type, SubExpr, Offset); }
 
   void printLeft(OutputBuffer &OB) const override {
-    OB += "(";
+    OB.printOpen();
     Type->print(OB);
-    OB += ")(";
+    OB.printClose();
+    OB.printOpen();
     SubExpr->print(OB);
-    OB += ")";
+    OB.printClose();
   }
 };
 
 class InitListExpr : public Node {
   const Node *Ty;
   NodeArray Inits;
 public:
   InitListExpr(const Node *Ty_, NodeArray Inits_)
FoldExpr(bool IsLeftFold_, StringView OperatorName_, const Node *Pack_,
         IsLeftFold(IsLeftFold_) {}
 
   template<typename Fn> void match(Fn F) const {
     F(IsLeftFold, OperatorName, Pack, Init);
   }
 
   void printLeft(OutputBuffer &OB) const override {
     auto PrintPack = [&] {
-      OB += '(';
+      OB.printOpen();
       ParameterPackExpansion(Pack).print(OB);
-      OB += ')';
+      OB.printClose();
     };
 
-    OB += '(';
-
-    if (IsLeftFold) {
-      // init op ... op pack
-      if (Init != nullptr) {
-        Init->print(OB);
-        OB += ' ';
-        OB += OperatorName;
-        OB += ' ';
-      }
-      // ... op pack
-      OB += "... ";
-      OB += OperatorName;
-      OB += ' ';
-      PrintPack();
-    } else { // !IsLeftFold
-      // pack op ...
+    OB.printOpen();
+    // Either '[init op ]... op pack' or 'pack op ...[ op init]'
+    // Refactored to '[(init|pack) op ]...[ op (pack|init)]'
+    // Fold expr operands are cast-expressions
+    if (!IsLeftFold || Init != nullptr) {
+      // '(init|pack) op '
+      if (IsLeftFold)
+        Init->printAsOperand(OB, Prec::Cast, true);
+      else
         PrintPack();
-      OB += ' ';
-      OB += OperatorName;
-      OB += " ...";
-      // pack op ... op init
-      if (Init != nullptr) {
-        OB += ' ';
-        OB += OperatorName;
-        OB += ' ';
-        Init->print(OB);
-      }
+      OB << " " << OperatorName << " ";
+    OB << "...";
+    if (IsLeftFold || Init != nullptr) {
+      // ' op (init|pack)'
+      OB << " " << OperatorName << " ";
+      if (IsLeftFold)
+        PrintPack();
+      else
+        Init->printAsOperand(OB, Prec::Cast, true);
     }
-    OB += ')';
+    OB.printClose();
   }
 };
 
 class ThrowExpr : public Node {
   const Node *Op;
 
 public:
   ThrowExpr(const Node *Op_) : Node(KThrowExpr), Op(Op_) {}

 
 public:
   EnumLiteral(const Node *Ty_, StringView Integer_)
       : Node(KEnumLiteral), Ty(Ty_), Integer(Integer_) {}
 
   template<typename Fn> void match(Fn F) const { F(Ty, Integer); }
 
   void printLeft(OutputBuffer &OB) const override {
-    OB << "(";
+    OB.printOpen();
     Ty->print(OB);
-    OB << ")";
+    OB.printClose();
 
     if (Integer[0] == 'n')
       OB << "-" << Integer.dropFront(1);
     else
       OB << Integer;
   }
 };
 
 class IntegerLiteral : public Node {
   StringView Type;
   StringView Value;
 
 public:
   IntegerLiteral(StringView Type_, StringView Value_)
       : Node(KIntegerLiteral), Type(Type_), Value(Value_) {}
 
   template<typename Fn> void match(Fn F) const { F(Type, Value); }
 
   void printLeft(OutputBuffer &OB) const override {
     if (Type.size() > 3) {
-      OB += "(";
+      OB.printOpen();
       OB += Type;
-      OB += ")";
+      OB.printClose();
     }
 
     if (Value[0] == 'n') {
-      OB += "-";
+      OB += '-';
       OB += Value.dropFront(1);
     } else
       OB += Value;
 
     if (Type.size() <= 3)
       OB += Type;
   }
 };
template <typename Derived, typename Alloc> struct AbstractManglingParser {
   Node *parseSubstitution();
   Node *parseTemplateParam();
   Node *parseTemplateParamDecl();
   Node *parseTemplateArgs(bool TagTemplates = false);
   Node *parseTemplateArg();
 
   /// Parse the <expr> production.
   Node *parseExpr();
-  Node *parsePrefixExpr(StringView Kind);
-  Node *parseBinaryExpr(StringView Kind);
+  Node *parsePrefixExpr(StringView Kind, Node::Prec Prec);
+  Node *parseBinaryExpr(StringView Kind, Node::Prec Prec);
   Node *parseIntegerLiteral(StringView Lit);
   Node *parseExprPrimary();
   template <class Float> Node *parseFloatingLiteral();
   Node *parseFunctionParam();
   Node *parseConversionExpr();
   Node *parseBracedExpr();
   Node *parseFoldExpr();
-  Node *parsePointerToMemberConversionExpr();
+  Node *parsePointerToMemberConversionExpr(Node::Prec Prec);
   Node *parseSubobjectExpr();
 
   /// Parse the <type> production.
   Node *parseType();
   Node *parseFunctionType();
   Node *parseVectorType();
   Node *parseDecltype();
   Node *parseArrayType();
enum OIKind : unsigned char {
       NamedCast, // Named cast, @<type>(expr)
       OfIdOp,    // alignof, sizeof, typeid
 
       Unnameable = NamedCast,
     };
     char Enc[2];      // Encoding
     OIKind Kind;      // Kind of operator
     bool Flag : 1;    // Entry-specific flag
+    Node::Prec Prec : 7; // Precedence
     const char *Name; // Spelling
 
   public:
-    constexpr OperatorInfo(const char (&E)[3], OIKind K, bool F, const char *N)
-        : Enc{E[0], E[1]}, Kind{K}, Flag{F}, Name{N} {}
+    constexpr OperatorInfo(const char (&E)[3], OIKind K, bool F, Node::Prec P,
+                           const char *N)
+        : Enc{E[0], E[1]}, Kind{K}, Flag{F}, Prec{P}, Name{N} {}
 
   public:
     bool operator<(const OperatorInfo &Other) const {
       return *this < Other.Enc;
     }
     bool operator<(const char *Peek) const {
       return Enc[0] < Peek[0] || (Enc[0] == Peek[0] && Enc[1] < Peek[1]);
     }
StringView getSymbol() const {
         Res = Res.dropFront(sizeof("operator") - 1);
         Res.consumeFront(' ');
       }
       return Res;
     }
     StringView getName() const { return Name; }
     OIKind getKind() const { return Kind; }
     bool getFlag() const { return Flag; }
+    Node::Prec getPrecedence() const { return Prec; }
   };
   const OperatorInfo *parseOperatorEncoding();
 
   /// Parse the <unresolved-name> production.
   Node *parseUnresolvedName(bool Global);
   Node *parseSimpleId();
   Node *parseBaseUnresolvedName();
   Node *parseUnresolvedType();

 
 // If the next 2 chars are an operator encoding, consume them and return their
 // OperatorInfo.  Otherwise return nullptr.
 template <typename Derived, typename Alloc>
 const typename AbstractManglingParser<Derived, Alloc>::OperatorInfo *
 AbstractManglingParser<Derived, Alloc>::parseOperatorEncoding() {
   static const OperatorInfo Ops[] = {
       // Keep ordered by encoding
-      {"aN", OperatorInfo::Binary, false, "operator&="},
-      {"aS", OperatorInfo::Binary, false, "operator="},
-      {"aa", OperatorInfo::Binary, false, "operator&&"},
-      {"ad", OperatorInfo::Prefix, false, "operator&"},
-      {"an", OperatorInfo::Binary, false, "operator&"},
-      {"at", OperatorInfo::OfIdOp, /*Type*/ true, "alignof ("},
-      {"aw", OperatorInfo::NameOnly, false, "operator co_await"},
-      {"az", OperatorInfo::OfIdOp, /*Type*/ false, "alignof ("},
-      {"cc", OperatorInfo::NamedCast, false, "const_cast"},
-      {"cl", OperatorInfo::Call, false, "operator()"},
-      {"cm", OperatorInfo::Binary, false, "operator,"},
-      {"co", OperatorInfo::Prefix, false, "operator~"},
-      {"cv", OperatorInfo::CCast, false, "operator"}, // C Cast
-      {"dV", OperatorInfo::Binary, false, "operator/="},
-      {"da", OperatorInfo::Del, /*Ary*/ true, "operator delete[]"},
-      {"dc", OperatorInfo::NamedCast, false, "dynamic_cast"},
-      {"de", OperatorInfo::Prefix, false, "operator*"},
-      {"dl", OperatorInfo::Del, /*Ary*/ false, "operator delete"},
-      {"ds", OperatorInfo::Member, /*Named*/ false, "operator.*"},
-      {"dt", OperatorInfo::Member, /*Named*/ false, "operator."},
-      {"dv", OperatorInfo::Binary, false, "operator/"},
-      {"eO", OperatorInfo::Binary, false, "operator^="},
-      {"eo", OperatorInfo::Binary, false, "operator^"},
-      {"eq", OperatorInfo::Binary, false, "operator=="},
-      {"ge", OperatorInfo::Binary, false, "operator>="},
-      {"gt", OperatorInfo::Binary, false, "operator>"},
-      {"ix", OperatorInfo::Array, false, "operator[]"},
-      {"lS", OperatorInfo::Binary, false, "operator<<="},
-      {"le", OperatorInfo::Binary, false, "operator<="},
-      {"ls", OperatorInfo::Binary, false, "operator<<"},
-      {"lt", OperatorInfo::Binary, false, "operator<"},
-      {"mI", OperatorInfo::Binary, false, "operator-="},
-      {"mL", OperatorInfo::Binary, false, "operator*="},
-      {"mi", OperatorInfo::Binary, false, "operator-"},
-      {"ml", OperatorInfo::Binary, false, "operator*"},
-      {"mm", OperatorInfo::Postfix, false, "operator--"},
-      {"na", OperatorInfo::New, /*Ary*/ true, "operator new[]"},
-      {"ne", OperatorInfo::Binary, false, "operator!="},
-      {"ng", OperatorInfo::Prefix, false, "operator-"},
-      {"nt", OperatorInfo::Prefix, false, "operator!"},
-      {"nw", OperatorInfo::New, /*Ary*/ false, "operator new"},
-      {"oR", OperatorInfo::Binary, false, "operator|="},
-      {"oo", OperatorInfo::Binary, false, "operator||"},
-      {"or", OperatorInfo::Binary, false, "operator|"},
-      {"pL", OperatorInfo::Binary, false, "operator+="},
-      {"pl", OperatorInfo::Binary, false, "operator+"},
-      {"pm", OperatorInfo::Member, /*Named*/ false, "operator->*"},
-      {"pp", OperatorInfo::Postfix, false, "operator++"},
-      {"ps", OperatorInfo::Prefix, false, "operator+"},
-      {"pt", OperatorInfo::Member, /*Named*/ true, "operator->"},
-      {"qu", OperatorInfo::Conditional, false, "operator?"},
-      {"rM", OperatorInfo::Binary, false, "operator%="},
-      {"rS", OperatorInfo::Binary, false, "operator>>="},
-      {"rc", OperatorInfo::NamedCast, false, "reinterpret_cast"},
-      {"rm", OperatorInfo::Binary, false, "operator%"},
-      {"rs", OperatorInfo::Binary, false, "operator>>"},
-      {"sc", OperatorInfo::NamedCast, false, "static_cast"},
-      {"ss", OperatorInfo::Binary, false, "operator<=>"},
-      {"st", OperatorInfo::OfIdOp, /*Type*/ true, "sizeof ("},
-      {"sz", OperatorInfo::OfIdOp, /*Type*/ false, "sizeof ("},
-      {"te", OperatorInfo::OfIdOp, /*Type*/ false, "typeid ("},
-      {"ti", OperatorInfo::OfIdOp, /*Type*/ true, "typeid ("},
+      {"aN", OperatorInfo::Binary, false, Node::Prec::Assign, "operator&="},
+      {"aS", OperatorInfo::Binary, false, Node::Prec::Assign, "operator="},
+      {"aa", OperatorInfo::Binary, false, Node::Prec::AndIf, "operator&&"},
+      {"ad", OperatorInfo::Prefix, false, Node::Prec::Unary, "operator&"},
+      {"an", OperatorInfo::Binary, false, Node::Prec::And, "operator&"},
+      {"at", OperatorInfo::OfIdOp, /*Type*/ true, Node::Prec::Unary,
+       "alignof "},
+      {"aw", OperatorInfo::NameOnly, false, Node::Prec::Primary,
+       "operator co_await"},
+      {"az", OperatorInfo::OfIdOp, /*Type*/ false, Node::Prec::Unary,
+       "alignof "},
+      {"cc", OperatorInfo::NamedCast, false, Node::Prec::Postfix, "const_cast"},
+      {"cl", OperatorInfo::Call, false, Node::Prec::Postfix, "operator()"},
+      {"cm", OperatorInfo::Binary, false, Node::Prec::Comma, "operator,"},
+      {"co", OperatorInfo::Prefix, false, Node::Prec::Unary, "operator~"},
+      {"cv", OperatorInfo::CCast, false, Node::Prec::Cast,
+       "operator"}, // C Cast
+      {"dV", OperatorInfo::Binary, false, Node::Prec::Assign, "operator/="},
+      {"da", OperatorInfo::Del, /*Ary*/ true, Node::Prec::Unary,
+       "operator delete[]"},
+      {"dc", OperatorInfo::NamedCast, false, Node::Prec::Postfix,
+       "dynamic_cast"},
+      {"de", OperatorInfo::Prefix, false, Node::Prec::Unary, "operator*"},
+      {"dl", OperatorInfo::Del, /*Ary*/ false, Node::Prec::Unary,
+       "operator delete"},
+      {"ds", OperatorInfo::Member, /*Named*/ false, Node::Prec::PtrMem,
+       "operator.*"},
+      {"dt", OperatorInfo::Member, /*Named*/ false, Node::Prec::Postfix,
+       "operator."},
+      {"dv", OperatorInfo::Binary, false, Node::Prec::Assign, "operator/"},
+      {"eO", OperatorInfo::Binary, false, Node::Prec::Assign, "operator^="},
+      {"eo", OperatorInfo::Binary, false, Node::Prec::Xor, "operator^"},
+      {"eq", OperatorInfo::Binary, false, Node::Prec::Equality, "operator=="},
+      {"ge", OperatorInfo::Binary, false, Node::Prec::Relational, "operator>="},
+      {"gt", OperatorInfo::Binary, false, Node::Prec::Relational, "operator>"},
+      {"ix", OperatorInfo::Array, false, Node::Prec::Postfix, "operator[]"},
+      {"lS", OperatorInfo::Binary, false, Node::Prec::Assign, "operator<<="},
+      {"le", OperatorInfo::Binary, false, Node::Prec::Relational, "operator<="},
+      {"ls", OperatorInfo::Binary, false, Node::Prec::Shift, "operator<<"},
+      {"lt", OperatorInfo::Binary, false, Node::Prec::Relational, "operator<"},
+      {"mI", OperatorInfo::Binary, false, Node::Prec::Assign, "operator-="},
+      {"mL", OperatorInfo::Binary, false, Node::Prec::Assign, "operator*="},
+      {"mi", OperatorInfo::Binary, false, Node::Prec::Additive, "operator-"},
+      {"ml", OperatorInfo::Binary, false, Node::Prec::Multiplicative,
+       "operator*"},
+      {"mm", OperatorInfo::Postfix, false, Node::Prec::Postfix, "operator--"},
+      {"na", OperatorInfo::New, /*Ary*/ true, Node::Prec::Unary,
+       "operator new[]"},
+      {"ne", OperatorInfo::Binary, false, Node::Prec::Equality, "operator!="},
+      {"ng", OperatorInfo::Prefix, false, Node::Prec::Unary, "operator-"},
+      {"nt", OperatorInfo::Prefix, false, Node::Prec::Unary, "operator!"},
+      {"nw", OperatorInfo::New, /*Ary*/ false, Node::Prec::Unary,
+       "operator new"},
+      {"oR", OperatorInfo::Binary, false, Node::Prec::Assign, "operator|="},
+      {"oo", OperatorInfo::Binary, false, Node::Prec::OrIf, "operator||"},
+      {"or", OperatorInfo::Binary, false, Node::Prec::Ior, "operator|"},
+      {"pL", OperatorInfo::Binary, false, Node::Prec::Assign, "operator+="},
+      {"pl", OperatorInfo::Binary, false, Node::Prec::Additive, "operator+"},
+      {"pm", OperatorInfo::Member, /*Named*/ false, Node::Prec::PtrMem,
+       "operator->*"},
+      {"pp", OperatorInfo::Postfix, false, Node::Prec::Postfix, "operator++"},
+      {"ps", OperatorInfo::Prefix, false, Node::Prec::Unary, "operator+"},
+      {"pt", OperatorInfo::Member, /*Named*/ true, Node::Prec::Postfix,
+       "operator->"},
+      {"qu", OperatorInfo::Conditional, false, Node::Prec::Conditional,
+       "operator?"},
+      {"rM", OperatorInfo::Binary, false, Node::Prec::Assign, "operator%="},
+      {"rS", OperatorInfo::Binary, false, Node::Prec::Assign, "operator>>="},
+      {"rc", OperatorInfo::NamedCast, false, Node::Prec::Postfix,
+       "reinterpret_cast"},
+      {"rm", OperatorInfo::Binary, false, Node::Prec::Multiplicative,
+       "operator%"},
+      {"rs", OperatorInfo::Binary, false, Node::Prec::Shift, "operator>>"},
+      {"sc", OperatorInfo::NamedCast, false, Node::Prec::Postfix,
+       "static_cast"},
+      {"ss", OperatorInfo::Binary, false, Node::Prec::Spaceship, "operator<=>"},
+      {"st", OperatorInfo::OfIdOp, /*Type*/ true, Node::Prec::Unary, "sizeof "},
+      {"sz", OperatorInfo::OfIdOp, /*Type*/ false, Node::Prec::Unary,
+       "sizeof "},
+      {"te", OperatorInfo::OfIdOp, /*Type*/ false, Node::Prec::Postfix,
+       "typeid "},
+      {"ti", OperatorInfo::OfIdOp, /*Type*/ true, Node::Prec::Postfix,
+       "typeid "},
   };
   const auto NumOps = sizeof(Ops) / sizeof(Ops[0]);
 
 #ifndef NDEBUG
   {
     // Verify table order.
     static bool Done;
     if (!Done) {
if (!consumeIf('D'))
     return nullptr;
   if (!consumeIf('t') && !consumeIf('T'))
     return nullptr;
   Node *E = getDerived().parseExpr();
   if (E == nullptr)
     return nullptr;
   if (!consumeIf('E'))
     return nullptr;
-  return make<EnclosingExpr>("decltype(", E, ")");
+  return make<EnclosingExpr>("decltype", E);
 }
 
 // <array-type> ::= A <positive dimension number> _ <element type>
 //              ::= A [<dimension expression>] _ <element type>
 template <typename Derived, typename Alloc>
 Node *AbstractManglingParser<Derived, Alloc>::parseArrayType() {
   if (!consumeIf('A'))
     return nullptr;
Node *AbstractManglingParser<Derived, Alloc>::parseType() {
   // <builtin-type>s and <substitution>s have already bailed out, because they
   // don't get substitutions.
   if (Result != nullptr)
     Subs.push_back(Result);
   return Result;
 }
 
 template <typename Derived, typename Alloc>
-Node *AbstractManglingParser<Derived, Alloc>::parsePrefixExpr(StringView Kind) {
+Node *AbstractManglingParser<Derived, Alloc>::parsePrefixExpr(StringView Kind,
+                                                              Node::Prec Prec) {
   Node *E = getDerived().parseExpr();
   if (E == nullptr)
     return nullptr;
-  return make<PrefixExpr>(Kind, E);
+  return make<PrefixExpr>(Kind, E, Prec);
 }
 
 template <typename Derived, typename Alloc>
-Node *AbstractManglingParser<Derived, Alloc>::parseBinaryExpr(StringView Kind) {
+Node *AbstractManglingParser<Derived, Alloc>::parseBinaryExpr(StringView Kind,
+                                                              Node::Prec Prec) {
   Node *LHS = getDerived().parseExpr();
   if (LHS == nullptr)
     return nullptr;
   Node *RHS = getDerived().parseExpr();
   if (RHS == nullptr)
     return nullptr;
-  return make<BinaryExpr>(LHS, Kind, RHS);
+  return make<BinaryExpr>(LHS, Kind, RHS, Prec);
 }
 
 template <typename Derived, typename Alloc>
 Node *
 AbstractManglingParser<Derived, Alloc>::parseIntegerLiteral(StringView Lit) {
   StringView Tmp = parseNumber(true);
   if (!Tmp.empty() && consumeIf('E'))
     return make<IntegerLiteral>(Lit, Tmp);
Node *AbstractManglingParser<Derived, Alloc>::parseFoldExpr() {
 
   return make<FoldExpr>(IsLeftFold, Op->getSymbol(), Pack, Init);
 }
 
 // <expression> ::= mc <parameter type> <expr> [<offset number>] E
 //
 // Not yet in the spec: https://github.com/itanium-cxx-abi/cxx-abi/issues/47
 template <typename Derived, typename Alloc>
-Node *AbstractManglingParser<Derived, Alloc>::parsePointerToMemberConversionExpr() {
+Node *
+AbstractManglingParser<Derived, Alloc>::parsePointerToMemberConversionExpr(
+    Node::Prec Prec) {
   Node *Ty = getDerived().parseType();
   if (!Ty)
     return nullptr;
   Node *Expr = getDerived().parseExpr();
   if (!Expr)
     return nullptr;
   StringView Offset = getDerived().parseNumber(true);
   if (!consumeIf('E'))
     return nullptr;
-  return make<PointerToMemberConversionExpr>(Ty, Expr, Offset);
+  return make<PointerToMemberConversionExpr>(Ty, Expr, Offset, Prec);
 }
 
 // <expression> ::= so <referent type> <expr> [<offset number>] <union-selector>* [p] E
 // <union-selector> ::= _ [<number>]
 //
 // Not yet in the spec: https://github.com/itanium-cxx-abi/cxx-abi/issues/47
 template <typename Derived, typename Alloc>
 Node *AbstractManglingParser<Derived, Alloc>::parseSubobjectExpr() {
Node *AbstractManglingParser<Derived, Alloc>::parseExpr() {
   bool Global = consumeIf("gs");
 
   const auto *Op = parseOperatorEncoding();
   if (Op) {
     auto Sym = Op->getSymbol();
     switch (Op->getKind()) {
     case OperatorInfo::Binary:
       // Binary operator: lhs @ rhs
-      return getDerived().parseBinaryExpr(Sym);
+      return getDerived().parseBinaryExpr(Sym, Op->getPrecedence());
     case OperatorInfo::Prefix:
       // Prefix unary operator: @ expr
-      return getDerived().parsePrefixExpr(Sym);
+      return getDerived().parsePrefixExpr(Sym, Op->getPrecedence());
     case OperatorInfo::Postfix: {
       // Postfix unary operator: expr @
       if (consumeIf('_'))
-        return getDerived().parsePrefixExpr(Sym);
+        return getDerived().parsePrefixExpr(Sym, Op->getPrecedence());
       Node *Ex = getDerived().parseExpr();
       if (Ex == nullptr)
         return nullptr;
-      return make<PostfixExpr>(Ex, Sym);
+      return make<PostfixExpr>(Ex, Sym, Op->getPrecedence());
     }
     case OperatorInfo::Array: {
       // Array Index:  lhs [ rhs ]
       Node *Base = getDerived().parseExpr();
       if (Base == nullptr)
         return nullptr;
       Node *Index = getDerived().parseExpr();
       if (Index == nullptr)
         return nullptr;
-      return make<ArraySubscriptExpr>(Base, Index);
+      return make<ArraySubscriptExpr>(Base, Index, Op->getPrecedence());
     }
     case OperatorInfo::Member: {
       // Member access lhs @ rhs
       Node *LHS = getDerived().parseExpr();
       if (LHS == nullptr)
         return nullptr;
       Node *RHS = getDerived().parseExpr();
       if (RHS == nullptr)
         return nullptr;
-      return make<MemberExpr>(LHS, Sym, RHS);
+      return make<MemberExpr>(LHS, Sym, RHS, Op->getPrecedence());
     }
     case OperatorInfo::New: {
       // New
       // # new (expr-list) type [(init)]
       // [gs] nw <expression>* _ <type> [pi <expression>*] E
       // # new[] (expr-list) type [(init)]
       // [gs] na <expression>* _ <type> [pi <expression>*] E
       size_t Exprs = Names.size();
case OperatorInfo::New: {
           return nullptr;
         Node *Init = getDerived().parseExpr();
         if (Init == nullptr)
           return Init;
         Names.push_back(Init);
       }
       NodeArray Inits = popTrailingNodeArray(InitsBegin);
       return make<NewExpr>(ExprList, Ty, Inits, Global,
-                           /*IsArray=*/Op->getFlag());
+                           /*IsArray=*/Op->getFlag(), Op->getPrecedence());
     }
     case OperatorInfo::Del: {
       // Delete
       Node *Ex = getDerived().parseExpr();
       if (Ex == nullptr)
         return nullptr;
-      return make<DeleteExpr>(Ex, Global, /*IsArray=*/Op->getFlag());
+      return make<DeleteExpr>(Ex, Global, /*IsArray=*/Op->getFlag(),
+                              Op->getPrecedence());
     }
     case OperatorInfo::Call: {
       // Function Call
       Node *Callee = getDerived().parseExpr();
       if (Callee == nullptr)
         return nullptr;
       size_t ExprsBegin = Names.size();
       while (!consumeIf('E')) {
         Node *E = getDerived().parseExpr();
         if (E == nullptr)
           return nullptr;
         Names.push_back(E);
       }
-      return make<CallExpr>(Callee, popTrailingNodeArray(ExprsBegin));
+      return make<CallExpr>(Callee, popTrailingNodeArray(ExprsBegin),
+                            Op->getPrecedence());
     }
     case OperatorInfo::CCast: {
       // C Cast: (type)expr
       Node *Ty;
       {
         SwapAndRestore<bool> SaveTemp(TryToParseTemplateArgs, false);
         Ty = getDerived().parseType();
       }
       if (Ty == nullptr)
         return nullptr;
 
       size_t ExprsBegin = Names.size();
       bool IsMany = consumeIf('_');
       while (!consumeIf('E')) {
         Node *E = getDerived().parseExpr();
         if (E == nullptr)
           return E;
         Names.push_back(E);
         if (!IsMany)
           break;
       }
       NodeArray Exprs = popTrailingNodeArray(ExprsBegin);
       if (!IsMany && Exprs.size() != 1)
         return nullptr;
-      return make<ConversionExpr>(Ty, Exprs);
+      return make<ConversionExpr>(Ty, Exprs, Op->getPrecedence());
     }
     case OperatorInfo::Conditional: {
       // Conditional operator: expr ? expr : expr
       Node *Cond = getDerived().parseExpr();
       if (Cond == nullptr)
         return nullptr;
       Node *LHS = getDerived().parseExpr();
       if (LHS == nullptr)
         return nullptr;
       Node *RHS = getDerived().parseExpr();
       if (RHS == nullptr)
         return nullptr;
-      return make<ConditionalExpr>(Cond, LHS, RHS);
+      return make<ConditionalExpr>(Cond, LHS, RHS, Op->getPrecedence());
     }
     case OperatorInfo::NamedCast: {
       // Named cast operation, @<type>(expr)
       Node *Ty = getDerived().parseType();
       if (Ty == nullptr)
         return nullptr;
       Node *Ex = getDerived().parseExpr();
       if (Ex == nullptr)
         return nullptr;
-      return make<CastExpr>(Sym, Ty, Ex);
+      return make<CastExpr>(Sym, Ty, Ex, Op->getPrecedence());
     }
     case OperatorInfo::OfIdOp: {
       // [sizeof/alignof/typeid] ( <type>|<expr> )
       Node *Arg =
           Op->getFlag() ? getDerived().parseType() : getDerived().parseExpr();
       if (!Arg)
         return nullptr;
-      return make<EnclosingExpr>(Sym, Arg, ")");
+      return make<EnclosingExpr>(Sym, Arg, Op->getPrecedence());
     }
     case OperatorInfo::NameOnly: {
       // Not valid as an expression operand.
       return nullptr;
     }
     }
     DEMANGLE_UNREACHABLE;
   }
while (!consumeIf('E')) {
       Node *E = getDerived().parseBracedExpr();
       if (E == nullptr)
         return nullptr;
       Names.push_back(E);
     }
     return make<InitListExpr>(nullptr, popTrailingNodeArray(InitsBegin));
   }
   if (consumeIf("mc"))
-    return parsePointerToMemberConversionExpr();
+    return parsePointerToMemberConversionExpr(Node::Prec::Unary);
   if (consumeIf("nx")) {
     Node *Ex = getDerived().parseExpr();
     if (Ex == nullptr)
       return Ex;
-    return make<EnclosingExpr>("noexcept (", Ex, ")");
+    return make<EnclosingExpr>("noexcept ", Ex, Node::Prec::Unary);
   }
   if (consumeIf("so"))
     return parseSubobjectExpr();
   if (consumeIf("sp")) {
     Node *Child = getDerived().parseExpr();
     if (Child == nullptr)
       return nullptr;
     return make<ParameterPackExpansion>(Child);
   }
   if (consumeIf("sZ")) {
     if (look() == 'T') {
       Node *R = getDerived().parseTemplateParam();
       if (R == nullptr)
         return nullptr;
       return make<SizeofParamPackExpr>(R);
     }
     Node *FP = getDerived().parseFunctionParam();
     if (FP == nullptr)
       return nullptr;
-    return make<EnclosingExpr>("sizeof... (", FP, ")");
+    return make<EnclosingExpr>("sizeof... ", FP);
   }
   if (consumeIf("sP")) {
     size_t ArgsBegin = Names.size();
     while (!consumeIf('E')) {
       Node *Arg = getDerived().parseTemplateArg();
       if (Arg == nullptr)
         return nullptr;
       Names.push_back(Arg);
     }
     auto *Pack = make<NodeArrayNode>(popTrailingNodeArray(ArgsBegin));
     if (!Pack)
       return nullptr;
-    return make<EnclosingExpr>("sizeof... (", Pack, ")");
+    return make<EnclosingExpr>("sizeof... ", Pack);
   }
   if (consumeIf("tl")) {
     Node *Ty = getDerived().parseType();
     if (Ty == nullptr)
       return nullptr;
     size_t InitsBegin = Names.size();
     while (!consumeIf('E')) {
       Node *E = getDerived().parseBracedExpr();
if (consumeIf('u')) {
     } else {
       while (!consumeIf('E')) {
         Node *E = getDerived().parseTemplateArg();
         if (E == nullptr)
           return E;
         Names.push_back(E);
       }
     }
-    return make<CallExpr>(Name, popTrailingNodeArray(ExprsBegin));
+    return make<CallExpr>(Name, popTrailingNodeArray(ExprsBegin),
+                          Node::Prec::Postfix);
   }
 
   // Only unresolved names remain.
   return getDerived().parseUnresolvedName(Global);
 }
 
 // <call-offset> ::= h <nv-offset> _
 //               ::= v <v-offset> _

libcxxabi/src/demangle/Utility.h

void reset(char *Buffer_, size_t BufferCapacity_) {
     BufferCapacity = BufferCapacity_;
   }
 
   /// If a ParameterPackExpansion (or similar type) is encountered, the offset
   /// into the pack that we're currently printing.
   unsigned CurrentPackIndex = std::numeric_limits<unsigned>::max();
   unsigned CurrentPackMax = std::numeric_limits<unsigned>::max();
 
+  /// When zero, we're printing template args and '>' needs to be parenthesized.
+  /// Use a counter so we can simply increment inside parentheses.
+  unsigned GtIsGt = 1;
+
+  bool isGtInsideTemplateArgs() const { return GtIsGt == 0; }
+
+  void printOpen(char Open = '(') {
+    GtIsGt++;
+    *this += Open;
+  }
+  void printClose(char Close = ')') {
+    GtIsGt--;
+    *this += Close;
+  }
+
   OutputBuffer &operator+=(StringView R) {
     if (size_t Size = R.size()) {
       grow(Size);
       std::memcpy(Buffer + CurrentPosition, R.begin(), Size);
       CurrentPosition += Size;
     }
     return *this;
   }

libcxxabi/test/test_demangle.pass.cpp

     {"_ZN12_GLOBAL__N_111RewriteObjCD1Ev", "(anonymous namespace)::RewriteObjC::~RewriteObjC()"},
     {"_ZN12_GLOBAL__N_111RewriteObjCD0Ev", "(anonymous namespace)::RewriteObjC::~RewriteObjC()"},
     {"_ZN12_GLOBAL__N_111RewriteObjC10InitializeERN5clang10ASTContextE", "(anonymous namespace)::RewriteObjC::Initialize(clang::ASTContext&)"},
     {"_ZN12_GLOBAL__N_111RewriteObjC18HandleTopLevelDeclEN5clang12DeclGroupRefE", "(anonymous namespace)::RewriteObjC::HandleTopLevelDecl(clang::DeclGroupRef)"},
     {"_ZN12_GLOBAL__N_111RewriteObjC21HandleTranslationUnitERN5clang10ASTContextE", "(anonymous namespace)::RewriteObjC::HandleTranslationUnit(clang::ASTContext&)"},
     {"_ZN12_GLOBAL__N_111RewriteObjC27RewriteObjCProtocolMetaDataEPN5clang16ObjCProtocolDeclEN4llvm9StringRefES5_RSs", "(anonymous namespace)::RewriteObjC::RewriteObjCProtocolMetaData(clang::ObjCProtocolDecl*, llvm::StringRef, llvm::StringRef, std::string&)"},
     {"_ZN12_GLOBAL__N_111RewriteObjC28SynthesizeMetaDataIntoBufferERSs", "(anonymous namespace)::RewriteObjC::SynthesizeMetaDataIntoBuffer(std::string&)"},
     {"_ZN12_GLOBAL__N_111RewriteObjC26RewriteObjCMethodsMetaDataIPPN5clang14ObjCMethodDeclEEEvT_S6_bN4llvm9StringRefES8_RSs", "void (anonymous namespace)::RewriteObjC::RewriteObjCMethodsMetaData<clang::ObjCMethodDecl**>(clang::ObjCMethodDecl**, clang::ObjCMethodDecl**, bool, llvm::StringRef, llvm::StringRef, std::string&)"},
-    {"_ZN12_GLOBAL__N_111RewriteObjC26RewriteObjCMethodsMetaDataIN5clang11DeclContext22filtered_decl_iteratorINS2_14ObjCMethodDeclEXadL_ZNKS5_13isClassMethodEvEEEEEEvT_S7_bN4llvm9StringRefES9_RSs", "void (anonymous namespace)::RewriteObjC::RewriteObjCMethodsMetaData<clang::DeclContext::filtered_decl_iterator<clang::ObjCMethodDecl, &(clang::ObjCMethodDecl::isClassMethod() const)> >(clang::DeclContext::filtered_decl_iterator<clang::ObjCMethodDecl, &(clang::ObjCMethodDecl::isClassMethod() const)>, clang::DeclContext::filtered_decl_iterator<clang::ObjCMethodDecl, &(clang::ObjCMethodDecl::isClassMethod() const)>, bool, llvm::StringRef, llvm::StringRef, std::string&)"},
+    {"_ZN12_GLOBAL__N_111RewriteObjC26RewriteObjCMethodsMetaDataIN5clang11DeclContext22filtered_decl_iteratorINS2_14ObjCMethodDeclEXadL_ZNKS5_13isClassMethodEvEEEEEEvT_S7_bN4llvm9StringRefES9_RSs",
+     "void (anonymous namespace)::RewriteObjC::RewriteObjCMethodsMetaData<clang::DeclContext::filtered_decl_iterator<clang::ObjCMethodDecl, &clang::ObjCMethodDecl::isClassMethod() const> >(clang::DeclContext::filtered_decl_iterator<clang::ObjCMethodDecl, &clang::ObjCMethodDecl::isClassMethod() const>, clang::DeclContext::filtered_decl_iterator<clang::ObjCMethodDecl, &clang::ObjCMethodDecl::isClassMethod() const>, bool, llvm::StringRef, llvm::StringRef, std::string&)"},
     {"_ZN12_GLOBAL__N_111RewriteObjC31RewriteObjCProtocolListMetaDataERKN5clang8ObjCListINS1_16ObjCProtocolDeclEEEN4llvm9StringRefES8_RSs", "(anonymous namespace)::RewriteObjC::RewriteObjCProtocolListMetaData(clang::ObjCList<clang::ObjCProtocolDecl> const&, llvm::StringRef, llvm::StringRef, std::string&)"},
     {"_ZN12_GLOBAL__N_111RewriteObjC28SynthesizeObjCInternalStructEPN5clang17ObjCInterfaceDeclERSs", "(anonymous namespace)::RewriteObjC::SynthesizeObjCInternalStruct(clang::ObjCInterfaceDecl*, std::string&)"},
     {"_ZN12_GLOBAL__N_111RewriteObjC17QuoteDoublequotesERSsS1_", "(anonymous namespace)::RewriteObjC::QuoteDoublequotes(std::string&, std::string&)"},
     {"_ZN12_GLOBAL__N_111RewriteObjC31SynthesizeIvarOffsetComputationEPN5clang12ObjCIvarDeclERSs", "(anonymous namespace)::RewriteObjC::SynthesizeIvarOffsetComputation(clang::ObjCIvarDecl*, std::string&)"},
     {"_ZN12_GLOBAL__N_111RewriteObjC25RewriteImplementationDeclEPN5clang4DeclE", "(anonymous namespace)::RewriteObjC::RewriteImplementationDecl(clang::Decl*)"},
     {"_ZN12_GLOBAL__N_111RewriteObjC21RewriteObjCMethodDeclEPKN5clang17ObjCInterfaceDeclEPNS1_14ObjCMethodDeclERSs", "(anonymous namespace)::RewriteObjC::RewriteObjCMethodDecl(clang::ObjCInterfaceDecl const*, clang::ObjCMethodDecl*, std::string&)"},
     {"_ZN12_GLOBAL__N_111RewriteObjC21RewriteTypeIntoStringEN5clang8QualTypeERSsRPKNS1_12FunctionTypeE", "(anonymous namespace)::RewriteObjC::RewriteTypeIntoString(clang::QualType, std::string&, clang::FunctionType const*&)"},
     {"_Z19getIvarAccessStringPN5clang12ObjCIvarDeclE", "getIvarAccessString(clang::ObjCIvarDecl*)"},

     {"_ZN12_GLOBAL__N_111RewriteObjC28SynthesizeCallToFunctionDeclEPN5clang12FunctionDeclEPPNS1_4ExprEjNS1_14SourceLocationES7_", "(anonymous namespace)::RewriteObjC::SynthesizeCallToFunctionDecl(clang::FunctionDecl*, clang::Expr**, unsigned int, clang::SourceLocation, clang::SourceLocation)"},
     {"_ZN12_GLOBAL__N_111RewriteObjC18getSuperStructTypeEv", "(anonymous namespace)::RewriteObjC::getSuperStructType()"},
     {"_ZN12_GLOBAL__N_111RewriteObjC32SynthSuperContructorFunctionDeclEv", "(anonymous namespace)::RewriteObjC::SynthSuperContructorFunctionDecl()"},
     {"_ZN12_GLOBAL__N_111RewriteObjC26SynthBlockInitFunctionDeclEN4llvm9StringRefE", "(anonymous namespace)::RewriteObjC::SynthBlockInitFunctionDecl(llvm::StringRef)"},
     {"_ZN12_GLOBAL__N_111RewriteObjC24RewriteMethodDeclarationEPN5clang14ObjCMethodDeclE", "(anonymous namespace)::RewriteObjC::RewriteMethodDeclaration(clang::ObjCMethodDecl*)"},
     {"_ZN4llvm8DenseMapIPN5clang14ObjCMethodDeclESsNS_12DenseMapInfoIS3_EENS4_ISsEEE16FindAndConstructERKS3_", "llvm::DenseMap<clang::ObjCMethodDecl*, std::string, llvm::DenseMapInfo<clang::ObjCMethodDecl*>, llvm::DenseMapInfo<std::string> >::FindAndConstruct(clang::ObjCMethodDecl* const&)"},
     {"_ZN4llvm8DenseMapIPN5clang14ObjCMethodDeclESsNS_12DenseMapInfoIS3_EENS4_ISsEEE16InsertIntoBucketERKS3_RKSsPSt4pairIS3_SsE", "llvm::DenseMap<clang::ObjCMethodDecl*, std::string, llvm::DenseMapInfo<clang::ObjCMethodDecl*>, llvm::DenseMapInfo<std::string> >::InsertIntoBucket(clang::ObjCMethodDecl* const&, std::string const&, std::pair<clang::ObjCMethodDecl*, std::string>*)"},
     {"_ZN4llvm8DenseMapIPN5clang14ObjCMethodDeclESsNS_12DenseMapInfoIS3_EENS4_ISsEEE4growEj", "llvm::DenseMap<clang::ObjCMethodDecl*, std::string, llvm::DenseMapInfo<clang::ObjCMethodDecl*>, llvm::DenseMapInfo<std::string> >::grow(unsigned int)"},
-    {"_ZN4llvm15SmallVectorImplIPN5clang14ObjCMethodDeclEE6appendINS1_11DeclContext22filtered_decl_iteratorIS2_XadL_ZNKS2_16isInstanceMethodEvEEEEEEvT_S9_", "void llvm::SmallVectorImpl<clang::ObjCMethodDecl*>::append<clang::DeclContext::filtered_decl_iterator<clang::ObjCMethodDecl, &(clang::ObjCMethodDecl::isInstanceMethod() const)> >(clang::DeclContext::filtered_decl_iterator<clang::ObjCMethodDecl, &(clang::ObjCMethodDecl::isInstanceMethod() const)>, clang::DeclContext::filtered_decl_iterator<clang::ObjCMethodDecl, &(clang::ObjCMethodDecl::isInstanceMethod() const)>)"},
+    {"_ZN4llvm15SmallVectorImplIPN5clang14ObjCMethodDeclEE6appendINS1_11DeclContext22filtered_decl_iteratorIS2_XadL_ZNKS2_16isInstanceMethodEvEEEEEEvT_S9_", "void llvm::SmallVectorImpl<clang::ObjCMethodDecl*>::append<clang::DeclContext::filtered_decl_iterator<clang::ObjCMethodDecl, &clang::ObjCMethodDecl::isInstanceMethod() const> >(clang::DeclContext::filtered_decl_iterator<clang::ObjCMethodDecl, &clang::ObjCMethodDecl::isInstanceMethod() const>, clang::DeclContext::filtered_decl_iterator<clang::ObjCMethodDecl, &clang::ObjCMethodDecl::isInstanceMethod() const>)"},
     {"_ZNK5clang17ObjCInterfaceDecl9ivar_sizeEv", "clang::ObjCInterfaceDecl::ivar_size() const"},
     {"_ZNSs12_S_constructIN5clang22RopePieceBTreeIteratorEEEPcT_S3_RKSaIcESt20forward_iterator_tag", "char* std::string::_S_construct<clang::RopePieceBTreeIterator>(clang::RopePieceBTreeIterator, clang::RopePieceBTreeIterator, std::allocator<char> const&, std::forward_iterator_tag)"},
     {"_ZN4llvm8DenseMapIPN5clang9BlockExprESsNS_12DenseMapInfoIS3_EENS4_ISsEEE5clearEv", "llvm::DenseMap<clang::BlockExpr*, std::string, llvm::DenseMapInfo<clang::BlockExpr*>, llvm::DenseMapInfo<std::string> >::clear()"},
     {"_ZN4llvm8DenseMapIPN5clang9BlockExprESsNS_12DenseMapInfoIS3_EENS4_ISsEEE16shrink_and_clearEv", "llvm::DenseMap<clang::BlockExpr*, std::string, llvm::DenseMapInfo<clang::BlockExpr*>, llvm::DenseMapInfo<std::string> >::shrink_and_clear()"},
     {"_ZN4llvm8DenseMapIPN5clang9BlockExprESsNS_12DenseMapInfoIS3_EENS4_ISsEEE16FindAndConstructERKS3_", "llvm::DenseMap<clang::BlockExpr*, std::string, llvm::DenseMapInfo<clang::BlockExpr*>, llvm::DenseMapInfo<std::string> >::FindAndConstruct(clang::BlockExpr* const&)"},
     {"_ZN4llvm8DenseMapIPN5clang9BlockExprESsNS_12DenseMapInfoIS3_EENS4_ISsEEE16InsertIntoBucketERKS3_RKSsPSt4pairIS3_SsE", "llvm::DenseMap<clang::BlockExpr*, std::string, llvm::DenseMapInfo<clang::BlockExpr*>, llvm::DenseMapInfo<std::string> >::InsertIntoBucket(clang::BlockExpr* const&, std::string const&, std::pair<clang::BlockExpr*, std::string>*)"},
     {"_ZN4llvm8DenseMapIPN5clang9BlockExprESsNS_12DenseMapInfoIS3_EENS4_ISsEEE4growEj", "llvm::DenseMap<clang::BlockExpr*, std::string, llvm::DenseMapInfo<clang::BlockExpr*>, llvm::DenseMapInfo<std::string> >::grow(unsigned int)"},
     {"_ZN4llvm8DenseMapIPN5clang9ValueDeclEjNS_12DenseMapInfoIS3_EENS4_IjEEE16InsertIntoBucketERKS3_RKjPSt4pairIS3_jE", "llvm::DenseMap<clang::ValueDecl*, unsigned int, llvm::DenseMapInfo<clang::ValueDecl*>, llvm::DenseMapInfo<unsigned int> >::InsertIntoBucket(clang::ValueDecl* const&, unsigned int const&, std::pair<clang::ValueDecl*, unsigned int>*)"},

     {"_ZN12_GLOBAL__N_19AsmParser17ParseDirectiveSetEN4llvm9StringRefEb", "(anonymous namespace)::AsmParser::ParseDirectiveSet(llvm::StringRef, bool)"},
     {"_ZN12_GLOBAL__N_19AsmParser19ParseDirectiveAsciiEN4llvm9StringRefEb", "(anonymous namespace)::AsmParser::ParseDirectiveAscii(llvm::StringRef, bool)"},
     {"_ZN12_GLOBAL__N_19AsmParser19ParseDirectiveValueEj", "(anonymous namespace)::AsmParser::ParseDirectiveValue(unsigned int)"},
     {"_ZN12_GLOBAL__N_19AsmParser23ParseDirectiveRealValueERKN4llvm12fltSemanticsE", "(anonymous namespace)::AsmParser::ParseDirectiveRealValue(llvm::fltSemantics const&)"},
     {"_ZN12_GLOBAL__N_19AsmParser19ParseDirectiveAlignEbj", "(anonymous namespace)::AsmParser::ParseDirectiveAlign(bool, unsigned int)"},
     {"_ZN12_GLOBAL__N_19AsmParser29ParseDirectiveSymbolAttributeEN4llvm12MCSymbolAttrE", "(anonymous namespace)::AsmParser::ParseDirectiveSymbolAttribute(llvm::MCSymbolAttr)"},
     {"_ZN12_GLOBAL__N_19AsmParser18ParseDirectiveCommEb", "(anonymous namespace)::AsmParser::ParseDirectiveComm(bool)"},
     {"_Z8MarkUsedPKN4llvm6MCExprE", "MarkUsed(llvm::MCExpr const*)"},
-    {"_ZN12_GLOBAL__N_116GenericAsmParserD1Ev", "(anonymous namespace)::GenericAsmParser::~GenericAsmParser()"},
-    {"_ZN12_GLOBAL__N_116GenericAsmParserD0Ev", "(anonymous namespace)::GenericAsmParser::~GenericAsmParser()"},
-    {"_ZN12_GLOBAL__N_116GenericAsmParser10InitializeERN4llvm11MCAsmParserE", "(anonymous namespace)::GenericAsmParser::Initialize(llvm::MCAsmParser&)"},
-    {"_ZN4llvm20MCAsmParserExtension15HandleDirectiveIN12_GLOBAL__N_116GenericAsmParserEXadL_ZNS3_20ParseDirectiveLEB128ENS_9StringRefENS_5SMLocEEEEEbPS0_S4_S5_", "bool llvm::MCAsmParserExtension::HandleDirective<(anonymous namespace)::GenericAsmParser, &((anonymous namespace)::GenericAsmParser::ParseDirectiveLEB128(llvm::StringRef, llvm::SMLoc))>(llvm::MCAsmParserExtension*, llvm::StringRef, llvm::SMLoc)"},
-    {"_ZN4llvm20MCAsmParserExtension15HandleDirectiveIN12_GLOBAL__N_116GenericAsmParserEXadL_ZNS3_22ParseDirectiveEndMacroENS_9StringRefENS_5SMLocEEEEEbPS0_S4_S5_", "bool llvm::MCAsmParserExtension::HandleDirective<(anonymous namespace)::GenericAsmParser, &((anonymous namespace)::GenericAsmParser::ParseDirectiveEndMacro(llvm::StringRef, llvm::SMLoc))>(llvm::MCAsmParserExtension*, llvm::StringRef, llvm::SMLoc)"},
-    {"_ZN4llvm20MCAsmParserExtension15HandleDirectiveIN12_GLOBAL__N_116GenericAsmParserEXadL_ZNS3_19ParseDirectiveMacroENS_9StringRefENS_5SMLocEEEEEbPS0_S4_S5_", "bool llvm::MCAsmParserExtension::HandleDirective<(anonymous namespace)::GenericAsmParser, &((anonymous namespace)::GenericAsmParser::ParseDirectiveMacro(llvm::StringRef, llvm::SMLoc))>(llvm::MCAsmParserExtension*, llvm::StringRef, llvm::SMLoc)"},
-    {"_ZN4llvm20MCAsmParserExtension15HandleDirectiveIN12_GLOBAL__N_116GenericAsmParserEXadL_ZNS3_25ParseDirectiveMacrosOnOffENS_9StringRefENS_5SMLocEEEEEbPS0_S4_S5_", "bool llvm::MCAsmParserExtension::HandleDirective<(anonymous namespace)::GenericAsmParser, &((anonymous namespace)::GenericAsmParser::ParseDirectiveMacrosOnOff(llvm::StringRef, llvm::SMLoc))>(llvm::MCAsmParserExtension*, llvm::StringRef, llvm::SMLoc)"},
-    {"_ZN4llvm20MCAsmParserExtension15HandleDirectiveIN12_GLOBAL__N_116GenericAsmParserEXadL_ZNS3_29ParseDirectiveCFIRestoreStateENS_9StringRefENS_5SMLocEEEEEbPS0_S4_S5_", "bool llvm::MCAsmParserExtension::HandleDirective<(anonymous namespace)::GenericAsmParser, &((anonymous namespace)::GenericAsmParser::ParseDirectiveCFIRestoreState(llvm::StringRef, llvm::SMLoc))>(llvm::MCAsmParserExtension*, llvm::StringRef, llvm::SMLoc)"},
-    {"_ZN4llvm20MCAsmParserExtension15HandleDirectiveIN12_GLOBAL__N_116GenericAsmParserEXadL_ZNS3_30ParseDirectiveCFIRememberStateENS_9StringRefENS_5SMLocEEEEEbPS0_S4_S5_", "bool llvm::MCAsmParserExtension::HandleDirective<(anonymous namespace)::GenericAsmParser, &((anonymous namespace)::GenericAsmParser::ParseDirectiveCFIRememberState(llvm::StringRef, llvm::SMLoc))>(llvm::MCAsmParserExtension*, llvm::StringRef, llvm::SMLoc)"},
-    {"_ZN4llvm20MCAsmParserExtension15HandleDirectiveIN12_GLOBAL__N_116GenericAsmParserEXadL_ZNS3_34ParseDirectiveCFIPersonalityOrLsdaENS_9StringRefENS_5SMLocEEEEEbPS0_S4_S5_", "bool llvm::MCAsmParserExtension::HandleDirective<(anonymous namespace)::GenericAsmParser, &((anonymous namespace)::GenericAsmParser::ParseDirectiveCFIPersonalityOrLsda(llvm::StringRef, llvm::SMLoc))>(llvm::MCAsmParserExtension*, llvm::StringRef, llvm::SMLoc)"},
-    {"_ZN4llvm20MCAsmParserExtension15HandleDirectiveIN12_GLOBAL__N_116GenericAsmParserEXadL_ZNS3_23ParseDirectiveCFIOffsetENS_9StringRefENS_5SMLocEEEEEbPS0_S4_S5_", "bool llvm::MCAsmParserExtension::HandleDirective<(anonymous namespace)::GenericAsmParser, &((anonymous namespace)::GenericAsmParser::ParseDirectiveCFIOffset(llvm::StringRef, llvm::SMLoc))>(llvm::MCAsmParserExtension*, llvm::StringRef, llvm::SMLoc)"},
-    {"_ZN12_GLOBAL__N_116GenericAsmParser29ParseRegisterOrRegisterNumberERxN4llvm5SMLocE", "(anonymous namespace)::GenericAsmParser::ParseRegisterOrRegisterNumber(long long&, llvm::SMLoc)"},
-    {"_ZN4llvm20MCAsmParserExtension15HandleDirectiveIN12_GLOBAL__N_116GenericAsmParserEXadL_ZNS3_31ParseDirectiveCFIDefCfaRegisterENS_9StringRefENS_5SMLocEEEEEbPS0_S4_S5_", "bool llvm::MCAsmParserExtension::HandleDirective<(anonymous namespace)::GenericAsmParser, &((anonymous namespace)::GenericAsmParser::ParseDirectiveCFIDefCfaRegister(llvm::StringRef, llvm::SMLoc))>(llvm::MCAsmParserExtension*, llvm::StringRef, llvm::SMLoc)"},
-    {"_ZN4llvm20MCAsmParserExtension15HandleDirectiveIN12_GLOBAL__N_116GenericAsmParserEXadL_ZNS3_29ParseDirectiveCFIDefCfaOffsetENS_9StringRefENS_5SMLocEEEEEbPS0_S4_S5_", "bool llvm::MCAsmParserExtension::HandleDirective<(anonymous namespace)::GenericAsmParser, &((anonymous namespace)::GenericAsmParser::ParseDirectiveCFIDefCfaOffset(llvm::StringRef, llvm::SMLoc))>(llvm::MCAsmParserExtension*, llvm::StringRef, llvm::SMLoc)"},
-    {"_ZN4llvm20MCAsmParserExtension15HandleDirectiveIN12_GLOBAL__N_116GenericAsmParserEXadL_ZNS3_23ParseDirectiveCFIDefCfaENS_9StringRefENS_5SMLocEEEEEbPS0_S4_S5_", "bool llvm::MCAsmParserExtension::HandleDirective<(anonymous namespace)::GenericAsmParser, &((anonymous namespace)::GenericAsmParser::ParseDirectiveCFIDefCfa(llvm::StringRef, llvm::SMLoc))>(llvm::MCAsmParserExtension*, llvm::StringRef, llvm::SMLoc)"},
-    {"_ZN4llvm20MCAsmParserExtension15HandleDirectiveIN12_GLOBAL__N_116GenericAsmParserEXadL_ZNS3_24ParseDirectiveCFIEndProcENS_9StringRefENS_5SMLocEEEEEbPS0_S4_S5_", "bool llvm::MCAsmParserExtension::HandleDirective<(anonymous namespace)::GenericAsmParser, &((anonymous namespace)::GenericAsmParser::ParseDirectiveCFIEndProc(llvm::StringRef, llvm::SMLoc))>(llvm::MCAsmParserExtension*, llvm::StringRef, llvm::SMLoc)"},
-    {"_ZN4llvm20MCAsmParserExtension15HandleDirectiveIN12_GLOBAL__N_116GenericAsmParserEXadL_ZNS3_26ParseDirectiveCFIStartProcENS_9StringRefENS_5SMLocEEEEEbPS0_S4_S5_", "bool llvm::MCAsmParserExtension::HandleDirective<(anonymous namespace)::GenericAsmParser, &((anonymous namespace)::GenericAsmParser::ParseDirectiveCFIStartProc(llvm::StringRef, llvm::SMLoc))>(llvm::MCAsmParserExtension*, llvm::StringRef, llvm::SMLoc)"},
-    {"_ZN4llvm20MCAsmParserExtension15HandleDirectiveIN12_GLOBAL__N_116GenericAsmParserEXadL_ZNS3_19ParseDirectiveStabsENS_9StringRefENS_5SMLocEEEEEbPS0_S4_S5_", "bool llvm::MCAsmParserExtension::HandleDirective<(anonymous namespace)::GenericAsmParser, &((anonymous namespace)::GenericAsmParser::ParseDirectiveStabs(llvm::StringRef, llvm::SMLoc))>(llvm::MCAsmParserExtension*, llvm::StringRef, llvm::SMLoc)"},
-    {"_ZN4llvm20MCAsmParserExtension15HandleDirectiveIN12_GLOBAL__N_116GenericAsmParserEXadL_ZNS3_17ParseDirectiveLocENS_9StringRefENS_5SMLocEEEEEbPS0_S4_S5_", "bool llvm::MCAsmParserExtension::HandleDirective<(anonymous namespace)::GenericAsmParser, &((anonymous namespace)::GenericAsmParser::ParseDirectiveLoc(llvm::StringRef, llvm::SMLoc))>(llvm::MCAsmParserExtension*, llvm::StringRef, llvm::SMLoc)"},
-    {"_ZN4llvm20MCAsmParserExtension15HandleDirectiveIN12_GLOBAL__N_116GenericAsmParserEXadL_ZNS3_18ParseDirectiveLineENS_9StringRefENS_5SMLocEEEEEbPS0_S4_S5_", "bool llvm::MCAsmParserExtension::HandleDirective<(anonymous namespace)::GenericAsmParser, &((anonymous namespace)::GenericAsmParser::ParseDirectiveLine(llvm::StringRef, llvm::SMLoc))>(llvm::MCAsmParserExtension*, llvm::StringRef, llvm::SMLoc)"},
-    {"_ZN4llvm20MCAsmParserExtension15HandleDirectiveIN12_GLOBAL__N_116GenericAsmParserEXadL_ZNS3_18ParseDirectiveFileENS_9StringRefENS_5SMLocEEEEEbPS0_S4_S5_", "bool llvm::MCAsmParserExtension::HandleDirective<(anonymous namespace)::GenericAsmParser, &((anonymous namespace)::GenericAsmParser::ParseDirectiveFile(llvm::StringRef, llvm::SMLoc))>(llvm::MCAsmParserExtension*, llvm::StringRef, llvm::SMLoc)"},
+    {"_ZN12_GLOBAL__N_116GenericAsmParserD1Ev",
+     "(anonymous namespace)::GenericAsmParser::~GenericAsmParser()"},
+    {"_ZN12_GLOBAL__N_116GenericAsmParserD0Ev",
+     "(anonymous namespace)::GenericAsmParser::~GenericAsmParser()"},
+    {"_ZN12_GLOBAL__N_116GenericAsmParser10InitializeERN4llvm11MCAsmParserE",
+     "(anonymous namespace)::GenericAsmParser::Initialize(llvm::MCAsmParser&)"},
+    {"_ZN4llvm20MCAsmParserExtension15HandleDirectiveIN12_GLOBAL__N_116GenericAsmParserEXadL_ZNS3_20ParseDirectiveLEB128ENS_9StringRefENS_5SMLocEEEEEbPS0_S4_S5_",
+     "bool llvm::MCAsmParserExtension::HandleDirective<(anonymous namespace)::GenericAsmParser, &(anonymous namespace)::GenericAsmParser::ParseDirectiveLEB128(llvm::StringRef, llvm::SMLoc)>(llvm::MCAsmParserExtension*, llvm::StringRef, llvm::SMLoc)"},
+    {"_ZN4llvm20MCAsmParserExtension15HandleDirectiveIN12_GLOBAL__N_116GenericAsmParserEXadL_ZNS3_22ParseDirectiveEndMacroENS_9StringRefENS_5SMLocEEEEEbPS0_S4_S5_",
+     "bool llvm::MCAsmParserExtension::HandleDirective<(anonymous namespace)::GenericAsmParser, &(anonymous namespace)::GenericAsmParser::ParseDirectiveEndMacro(llvm::StringRef, llvm::SMLoc)>(llvm::MCAsmParserExtension*, llvm::StringRef, llvm::SMLoc)"},
+    {"_ZN4llvm20MCAsmParserExtension15HandleDirectiveIN12_GLOBAL__N_116GenericAsmParserEXadL_ZNS3_19ParseDirectiveMacroENS_9StringRefENS_5SMLocEEEEEbPS0_S4_S5_",
+     "bool llvm::MCAsmParserExtension::HandleDirective<(anonymous namespace)::GenericAsmParser, &(anonymous namespace)::GenericAsmParser::ParseDirectiveMacro(llvm::StringRef, llvm::SMLoc)>(llvm::MCAsmParserExtension*, llvm::StringRef, llvm::SMLoc)"},
+    {"_ZN4llvm20MCAsmParserExtension15HandleDirectiveIN12_GLOBAL__N_116GenericAsmParserEXadL_ZNS3_25ParseDirectiveMacrosOnOffENS_9StringRefENS_5SMLocEEEEEbPS0_S4_S5_",
+     "bool llvm::MCAsmParserExtension::HandleDirective<(anonymous namespace)::GenericAsmParser, &(anonymous namespace)::GenericAsmParser::ParseDirectiveMacrosOnOff(llvm::StringRef, llvm::SMLoc)>(llvm::MCAsmParserExtension*, llvm::StringRef, llvm::SMLoc)"},
+    {"_ZN4llvm20MCAsmParserExtension15HandleDirectiveIN12_GLOBAL__N_116GenericAsmParserEXadL_ZNS3_29ParseDirectiveCFIRestoreStateENS_9StringRefENS_5SMLocEEEEEbPS0_S4_S5_",
+     "bool llvm::MCAsmParserExtension::HandleDirective<(anonymous namespace)::GenericAsmParser, &(anonymous namespace)::GenericAsmParser::ParseDirectiveCFIRestoreState(llvm::StringRef, llvm::SMLoc)>(llvm::MCAsmParserExtension*, llvm::StringRef, llvm::SMLoc)"},
+    {"_ZN4llvm20MCAsmParserExtension15HandleDirectiveIN12_GLOBAL__N_116GenericAsmParserEXadL_ZNS3_30ParseDirectiveCFIRememberStateENS_9StringRefENS_5SMLocEEEEEbPS0_S4_S5_",
+     "bool llvm::MCAsmParserExtension::HandleDirective<(anonymous namespace)::GenericAsmParser, &(anonymous namespace)::GenericAsmParser::ParseDirectiveCFIRememberState(llvm::StringRef, llvm::SMLoc)>(llvm::MCAsmParserExtension*, llvm::StringRef, llvm::SMLoc)"},
+    {"_ZN4llvm20MCAsmParserExtension15HandleDirectiveIN12_GLOBAL__N_116GenericAsmParserEXadL_ZNS3_34ParseDirectiveCFIPersonalityOrLsdaENS_9StringRefENS_5SMLocEEEEEbPS0_S4_S5_",
+     "bool llvm::MCAsmParserExtension::HandleDirective<(anonymous namespace)::GenericAsmParser, &(anonymous namespace)::GenericAsmParser::ParseDirectiveCFIPersonalityOrLsda(llvm::StringRef, llvm::SMLoc)>(llvm::MCAsmParserExtension*, llvm::StringRef, llvm::SMLoc)"},
+    {"_ZN4llvm20MCAsmParserExtension15HandleDirectiveIN12_GLOBAL__N_116GenericAsmParserEXadL_ZNS3_23ParseDirectiveCFIOffsetENS_9StringRefENS_5SMLocEEEEEbPS0_S4_S5_",
+     "bool llvm::MCAsmParserExtension::HandleDirective<(anonymous namespace)::GenericAsmParser, &(anonymous namespace)::GenericAsmParser::ParseDirectiveCFIOffset(llvm::StringRef, llvm::SMLoc)>(llvm::MCAsmParserExtension*, llvm::StringRef, llvm::SMLoc)"},
+    {"_ZN12_GLOBAL__N_116GenericAsmParser29ParseRegisterOrRegisterNumberERxN4llvm5SMLocE",
+     "(anonymous namespace)::GenericAsmParser::ParseRegisterOrRegisterNumber(long long&, llvm::SMLoc)"},
+    {"_ZN4llvm20MCAsmParserExtension15HandleDirectiveIN12_GLOBAL__N_116GenericAsmParserEXadL_ZNS3_31ParseDirectiveCFIDefCfaRegisterENS_9StringRefENS_5SMLocEEEEEbPS0_S4_S5_",
+     "bool llvm::MCAsmParserExtension::HandleDirective<(anonymous namespace)::GenericAsmParser, &(anonymous namespace)::GenericAsmParser::ParseDirectiveCFIDefCfaRegister(llvm::StringRef, llvm::SMLoc)>(llvm::MCAsmParserExtension*, llvm::StringRef, llvm::SMLoc)"},
+    {"_ZN4llvm20MCAsmParserExtension15HandleDirectiveIN12_GLOBAL__N_116GenericAsmParserEXadL_ZNS3_29ParseDirectiveCFIDefCfaOffsetENS_9StringRefENS_5SMLocEEEEEbPS0_S4_S5_",
+     "bool llvm::MCAsmParserExtension::HandleDirective<(anonymous namespace)::GenericAsmParser, &(anonymous namespace)::GenericAsmParser::ParseDirectiveCFIDefCfaOffset(llvm::StringRef, llvm::SMLoc)>(llvm::MCAsmParserExtension*, llvm::StringRef, llvm::SMLoc)"},
+    {"_ZN4llvm20MCAsmParserExtension15HandleDirectiveIN12_GLOBAL__N_116GenericAsmParserEXadL_ZNS3_23ParseDirectiveCFIDefCfaENS_9StringRefENS_5SMLocEEEEEbPS0_S4_S5_",
+     "bool llvm::MCAsmParserExtension::HandleDirective<(anonymous namespace)::GenericAsmParser, &(anonymous namespace)::GenericAsmParser::ParseDirectiveCFIDefCfa(llvm::StringRef, llvm::SMLoc)>(llvm::MCAsmParserExtension*, llvm::StringRef, llvm::SMLoc)"},
+    {"_ZN4llvm20MCAsmParserExtension15HandleDirectiveIN12_GLOBAL__N_116GenericAsmParserEXadL_ZNS3_24ParseDirectiveCFIEndProcENS_9StringRefENS_5SMLocEEEEEbPS0_S4_S5_",
+     "bool llvm::MCAsmParserExtension::HandleDirective<(anonymous namespace)::GenericAsmParser, &(anonymous namespace)::GenericAsmParser::ParseDirectiveCFIEndProc(llvm::StringRef, llvm::SMLoc)>(llvm::MCAsmParserExtension*, llvm::StringRef, llvm::SMLoc)"},
+    {"_ZN4llvm20MCAsmParserExtension15HandleDirectiveIN12_GLOBAL__N_116GenericAsmParserEXadL_ZNS3_26ParseDirectiveCFIStartProcENS_9StringRefENS_5SMLocEEEEEbPS0_S4_S5_",
+     "bool llvm::MCAsmParserExtension::HandleDirective<(anonymous namespace)::GenericAsmParser, &(anonymous namespace)::GenericAsmParser::ParseDirectiveCFIStartProc(llvm::StringRef, llvm::SMLoc)>(llvm::MCAsmParserExtension*, llvm::StringRef, llvm::SMLoc)"},
+    {"_ZN4llvm20MCAsmParserExtension15HandleDirectiveIN12_GLOBAL__N_116GenericAsmParserEXadL_ZNS3_19ParseDirectiveStabsENS_9StringRefENS_5SMLocEEEEEbPS0_S4_S5_",
+     "bool llvm::MCAsmParserExtension::HandleDirective<(anonymous namespace)::GenericAsmParser, &(anonymous namespace)::GenericAsmParser::ParseDirectiveStabs(llvm::StringRef, llvm::SMLoc)>(llvm::MCAsmParserExtension*, llvm::StringRef, llvm::SMLoc)"},
+    {"_ZN4llvm20MCAsmParserExtension15HandleDirectiveIN12_GLOBAL__N_116GenericAsmParserEXadL_ZNS3_17ParseDirectiveLocENS_9StringRefENS_5SMLocEEEEEbPS0_S4_S5_",
+     "bool llvm::MCAsmParserExtension::HandleDirective<(anonymous namespace)::GenericAsmParser, &(anonymous namespace)::GenericAsmParser::ParseDirectiveLoc(llvm::StringRef, llvm::SMLoc)>(llvm::MCAsmParserExtension*, llvm::StringRef, llvm::SMLoc)"},
+    {"_ZN4llvm20MCAsmParserExtension15HandleDirectiveIN12_GLOBAL__N_116GenericAsmParserEXadL_ZNS3_18ParseDirectiveLineENS_9StringRefENS_5SMLocEEEEEbPS0_S4_S5_",
+     "bool llvm::MCAsmParserExtension::HandleDirective<(anonymous namespace)::GenericAsmParser, &(anonymous namespace)::GenericAsmParser::ParseDirectiveLine(llvm::StringRef, llvm::SMLoc)>(llvm::MCAsmParserExtension*, llvm::StringRef, llvm::SMLoc)"},
+    {"_ZN4llvm20MCAsmParserExtension15HandleDirectiveIN12_GLOBAL__N_116GenericAsmParserEXadL_ZNS3_18ParseDirectiveFileENS_9StringRefENS_5SMLocEEEEEbPS0_S4_S5_",
+     "bool llvm::MCAsmParserExtension::HandleDirective<(anonymous namespace)::GenericAsmParser, &(anonymous namespace)::GenericAsmParser::ParseDirectiveFile(llvm::StringRef, llvm::SMLoc)>(llvm::MCAsmParserExtension*, llvm::StringRef, llvm::SMLoc)"},
     {"_ZNSt6vectorIN4llvm8AsmTokenESaIS1_EE13_M_insert_auxEN9__gnu_cxx17__normal_iteratorIPS1_S3_EERKS1_", "std::vector<llvm::AsmToken, std::allocator<llvm::AsmToken> >::_M_insert_aux(__gnu_cxx::__normal_iterator<llvm::AsmToken*, std::vector<llvm::AsmToken, std::allocator<llvm::AsmToken> > >, llvm::AsmToken const&)"},
     {"_ZNSt6vectorIS_IN4llvm8AsmTokenESaIS1_EESaIS3_EE13_M_insert_auxEN9__gnu_cxx17__normal_iteratorIPS3_S5_EERKS3_", "std::vector<std::vector<llvm::AsmToken, std::allocator<llvm::AsmToken> >, std::allocator<std::vector<llvm::AsmToken, std::allocator<llvm::AsmToken> > > >::_M_insert_aux(__gnu_cxx::__normal_iterator<std::vector<llvm::AsmToken, std::allocator<llvm::AsmToken> >*, std::vector<std::vector<llvm::AsmToken, std::allocator<llvm::AsmToken> >, std::allocator<std::vector<llvm::AsmToken, std::allocator<llvm::AsmToken> > > > >, std::vector<llvm::AsmToken, std::allocator<llvm::AsmToken> > const&)"},
     {"_ZNSt6vectorIN4llvm8AsmTokenESaIS1_EEaSERKS3_", "std::vector<llvm::AsmToken, std::allocator<llvm::AsmToken> >::operator=(std::vector<llvm::AsmToken, std::allocator<llvm::AsmToken> > const&)"},
     {"_ZNSt6vectorIN4llvm8AsmTokenESaIS1_EEC2ERKS3_", "std::vector<llvm::AsmToken, std::allocator<llvm::AsmToken> >::vector(std::vector<llvm::AsmToken, std::allocator<llvm::AsmToken> > const&)"},
     {"_ZNSt6vectorIN4llvm7AsmCondESaIS1_EE13_M_insert_auxEN9__gnu_cxx17__normal_iteratorIPS1_S3_EERKS1_", "std::vector<llvm::AsmCond, std::allocator<llvm::AsmCond> >::_M_insert_aux(__gnu_cxx::__normal_iterator<llvm::AsmCond*, std::vector<llvm::AsmCond, std::allocator<llvm::AsmCond> > >, llvm::AsmCond const&)"},
     {"_ZN4llvm9StringMapISt4pairIPNS_20MCAsmParserExtensionEPFbS3_NS_9StringRefENS_5SMLocEEENS_15MallocAllocatorEE16GetOrCreateValueIS8_EERNS_14StringMapEntryIS8_EES4_T_", "llvm::StringMapEntry<std::pair<llvm::MCAsmParserExtension*, bool (*)(llvm::MCAsmParserExtension*, llvm::StringRef, llvm::SMLoc)> >& llvm::StringMap<std::pair<llvm::MCAsmParserExtension*, bool (*)(llvm::MCAsmParserExtension*, llvm::StringRef, llvm::SMLoc)>, llvm::MallocAllocator>::GetOrCreateValue<std::pair<llvm::MCAsmParserExtension*, bool (*)(llvm::MCAsmParserExtension*, llvm::StringRef, llvm::SMLoc)> >(llvm::StringRef, std::pair<llvm::MCAsmParserExtension*, bool (*)(llvm::MCAsmParserExtension*, llvm::StringRef, llvm::SMLoc)>)"},
     {"_ZN4llvm19createCOFFAsmParserEv", "llvm::createCOFFAsmParser()"},
     {"_ZN12_GLOBAL__N_113COFFAsmParserD1Ev", "(anonymous namespace)::COFFAsmParser::~COFFAsmParser()"},
     {"_ZN12_GLOBAL__N_113COFFAsmParserD0Ev", "(anonymous namespace)::COFFAsmParser::~COFFAsmParser()"},
     {"_ZN12_GLOBAL__N_113COFFAsmParser10InitializeERN4llvm11MCAsmParserE", "(anonymous namespace)::COFFAsmParser::Initialize(llvm::MCAsmParser&)"},
-    {"_ZN4llvm20MCAsmParserExtension15HandleDirectiveIN12_GLOBAL__N_113COFFAsmParserEXadL_ZNS3_19ParseDirectiveEndefENS_9StringRefENS_5SMLocEEEEEbPS0_S4_S5_", "bool llvm::MCAsmParserExtension::HandleDirective<(anonymous namespace)::COFFAsmParser, &((anonymous namespace)::COFFAsmParser::ParseDirectiveEndef(llvm::StringRef, llvm::SMLoc))>(llvm::MCAsmParserExtension*, llvm::StringRef, llvm::SMLoc)"},
-    {"_ZN4llvm20MCAsmParserExtension15HandleDirectiveIN12_GLOBAL__N_113COFFAsmParserEXadL_ZNS3_18ParseDirectiveTypeENS_9StringRefENS_5SMLocEEEEEbPS0_S4_S5_", "bool llvm::MCAsmParserExtension::HandleDirective<(anonymous namespace)::COFFAsmParser, &((anonymous namespace)::COFFAsmParser::ParseDirectiveType(llvm::StringRef, llvm::SMLoc))>(llvm::MCAsmParserExtension*, llvm::StringRef, llvm::SMLoc)"},
-    {"_ZN4llvm20MCAsmParserExtension15HandleDirectiveIN12_GLOBAL__N_113COFFAsmParserEXadL_ZNS3_17ParseDirectiveSclENS_9StringRefENS_5SMLocEEEEEbPS0_S4_S5_", "bool llvm::MCAsmParserExtension::HandleDirective<(anonymous namespace)::COFFAsmParser, &((anonymous namespace)::COFFAsmParser::ParseDirectiveScl(llvm::StringRef, llvm::SMLoc))>(llvm::MCAsmParserExtension*, llvm::StringRef, llvm::SMLoc)"},
-    {"_ZN4llvm20MCAsmParserExtension15HandleDirectiveIN12_GLOBAL__N_113COFFAsmParserEXadL_ZNS3_17ParseDirectiveDefENS_9StringRefENS_5SMLocEEEEEbPS0_S4_S5_", "bool llvm::MCAsmParserExtension::HandleDirective<(anonymous namespace)::COFFAsmParser, &((anonymous namespace)::COFFAsmParser::ParseDirectiveDef(llvm::StringRef, llvm::SMLoc))>(llvm::MCAsmParserExtension*, llvm::StringRef, llvm::SMLoc)"},
-    {"_ZN4llvm20MCAsmParserExtension15HandleDirectiveIN12_GLOBAL__N_113COFFAsmParserEXadL_ZNS3_24ParseSectionDirectiveBSSENS_9StringRefENS_5SMLocEEEEEbPS0_S4_S5_", "bool llvm::MCAsmParserExtension::HandleDirective<(anonymous namespace)::COFFAsmParser, &((anonymous namespace)::COFFAsmParser::ParseSectionDirectiveBSS(llvm::StringRef, llvm::SMLoc))>(llvm::MCAsmParserExtension*, llvm::StringRef, llvm::SMLoc)"},
+    {"_ZN4llvm20MCAsmParserExtension15HandleDirectiveIN12_GLOBAL__N_113COFFAsmParserEXadL_ZNS3_19ParseDirectiveEndefENS_9StringRefENS_5SMLocEEEEEbPS0_S4_S5_",
+     "bool llvm::MCAsmParserExtension::HandleDirective<(anonymous namespace)::COFFAsmParser, &(anonymous namespace)::COFFAsmParser::ParseDirectiveEndef(llvm::StringRef, llvm::SMLoc)>(llvm::MCAsmParserExtension*, llvm::StringRef, llvm::SMLoc)"},
+    {"_ZN4llvm20MCAsmParserExtension15HandleDirectiveIN12_GLOBAL__N_113COFFAsmParserEXadL_ZNS3_18ParseDirectiveTypeENS_9StringRefENS_5SMLocEEEEEbPS0_S4_S5_",
+     "bool llvm::MCAsmParserExtension::HandleDirective<(anonymous namespace)::COFFAsmParser, &(anonymous namespace)::COFFAsmParser::ParseDirectiveType(llvm::StringRef, llvm::SMLoc)>(llvm::MCAsmParserExtension*, llvm::StringRef, llvm::SMLoc)"},
+    {"_ZN4llvm20MCAsmParserExtension15HandleDirectiveIN12_GLOBAL__N_113COFFAsmParserEXadL_ZNS3_17ParseDirectiveSclENS_9StringRefENS_5SMLocEEEEEbPS0_S4_S5_",
+     "bool llvm::MCAsmParserExtension::HandleDirective<(anonymous namespace)::COFFAsmParser, &(anonymous namespace)::COFFAsmParser::ParseDirectiveScl(llvm::StringRef, llvm::SMLoc)>(llvm::MCAsmParserExtension*, llvm::StringRef, llvm::SMLoc)"},
+    {"_ZN4llvm20MCAsmParserExtension15HandleDirectiveIN12_GLOBAL__N_113COFFAsmParserEXadL_ZNS3_17ParseDirectiveDefENS_9StringRefENS_5SMLocEEEEEbPS0_S4_S5_",
+     "bool llvm::MCAsmParserExtension::HandleDirective<(anonymous namespace)::COFFAsmParser, &(anonymous namespace)::COFFAsmParser::ParseDirectiveDef(llvm::StringRef, llvm::SMLoc)>(llvm::MCAsmParserExtension*, llvm::StringRef, llvm::SMLoc)"},
+    {"_ZN4llvm20MCAsmParserExtension15HandleDirectiveIN12_GLOBAL__N_113COFFAsmParserEXadL_ZNS3_24ParseSectionDirectiveBSSENS_9StringRefENS_5SMLocEEEEEbPS0_S4_S5_",
+     "bool llvm::MCAsmParserExtension::HandleDirective<(anonymous namespace)::COFFAsmParser, &(anonymous namespace)::COFFAsmParser::ParseSectionDirectiveBSS(llvm::StringRef, llvm::SMLoc)>(llvm::MCAsmParserExtension*, llvm::StringRef, llvm::SMLoc)"},
     {"_ZN12_GLOBAL__N_113COFFAsmParser18ParseSectionSwitchEN4llvm9StringRefEjNS1_11SectionKindE", "(anonymous namespace)::COFFAsmParser::ParseSectionSwitch(llvm::StringRef, unsigned int, llvm::SectionKind)"},
-    {"_ZN4llvm20MCAsmParserExtension15HandleDirectiveIN12_GLOBAL__N_113COFFAsmParserEXadL_ZNS3_25ParseSectionDirectiveDataENS_9StringRefENS_5SMLocEEEEEbPS0_S4_S5_", "bool llvm::MCAsmParserExtension::HandleDirective<(anonymous namespace)::COFFAsmParser, &((anonymous namespace)::COFFAsmParser::ParseSectionDirectiveData(llvm::StringRef, llvm::SMLoc))>(llvm::MCAsmParserExtension*, llvm::StringRef, llvm::SMLoc)"},
-    {"_ZN4llvm20MCAsmParserExtension15HandleDirectiveIN12_GLOBAL__N_113COFFAsmParserEXadL_ZNS3_25ParseSectionDirectiveTextENS_9StringRefENS_5SMLocEEEEEbPS0_S4_S5_", "bool llvm::MCAsmParserExtension::HandleDirective<(anonymous namespace)::COFFAsmParser, &((anonymous namespace)::COFFAsmParser::ParseSectionDirectiveText(llvm::StringRef, llvm::SMLoc))>(llvm::MCAsmParserExtension*, llvm::StringRef, llvm::SMLoc)"},
+    {"_ZN4llvm20MCAsmParserExtension15HandleDirectiveIN12_GLOBAL__N_113COFFAsmParserEXadL_ZNS3_25ParseSectionDirectiveDataENS_9StringRefENS_5SMLocEEEEEbPS0_S4_S5_",
+     "bool llvm::MCAsmParserExtension::HandleDirective<(anonymous namespace)::COFFAsmParser, &(anonymous namespace)::COFFAsmParser::ParseSectionDirectiveData(llvm::StringRef, llvm::SMLoc)>(llvm::MCAsmParserExtension*, llvm::StringRef, llvm::SMLoc)"},
+    {"_ZN4llvm20MCAsmParserExtension15HandleDirectiveIN12_GLOBAL__N_113COFFAsmParserEXadL_ZNS3_25ParseSectionDirectiveTextENS_9StringRefENS_5SMLocEEEEEbPS0_S4_S5_",
+     "bool llvm::MCAsmParserExtension::HandleDirective<(anonymous namespace)::COFFAsmParser, &(anonymous namespace)::COFFAsmParser::ParseSectionDirectiveText(llvm::StringRef, llvm::SMLoc)>(llvm::MCAsmParserExtension*, llvm::StringRef, llvm::SMLoc)"},
     {"_ZN4llvm21createDarwinAsmParserEv", "llvm::createDarwinAsmParser()"},
     {"_ZN12_GLOBAL__N_115DarwinAsmParserD1Ev", "(anonymous namespace)::DarwinAsmParser::~DarwinAsmParser()"},
     {"_ZN12_GLOBAL__N_115DarwinAsmParserD0Ev", "(anonymous namespace)::DarwinAsmParser::~DarwinAsmParser()"},
     {"_ZN12_GLOBAL__N_115DarwinAsmParser10InitializeERN4llvm11MCAsmParserE", "(anonymous namespace)::DarwinAsmParser::Initialize(llvm::MCAsmParser&)"},
-    {"_ZN4llvm20MCAsmParserExtension15HandleDirectiveIN12_GLOBAL__N_115DarwinAsmParserEXadL_ZNS3_24ParseSectionDirectiveTLVENS_9StringRefENS_5SMLocEEEEEbPS0_S4_S5_", "bool llvm::MCAsmParserExtension::HandleDirective<(anonymous namespace)::DarwinAsmParser, &((anonymous namespace)::DarwinAsmParser::ParseSectionDirectiveTLV(llvm::StringRef, llvm::SMLoc))>(llvm::MCAsmParserExtension*, llvm::StringRef, llvm::SMLoc)"},
+    {"_ZN4llvm20MCAsmParserExtension15HandleDirectiveIN12_GLOBAL__N_115DarwinAsmParserEXadL_ZNS3_24ParseSectionDirectiveTLVENS_9StringRefENS_5SMLocEEEEEbPS0_S4_S5_",
+     "bool llvm::MCAsmParserExtension::HandleDirective<(anonymous namespace)::DarwinAsmParser, &(anonymous namespace)::DarwinAsmParser::ParseSectionDirectiveTLV(llvm::StringRef, llvm::SMLoc)>(llvm::MCAsmParserExtension*, llvm::StringRef, llvm::SMLoc)"},
     {"_ZN12_GLOBAL__N_115DarwinAsmParser18ParseSectionSwitchEPKcS2_jjj", "(anonymous namespace)::DarwinAsmParser::ParseSectionSwitch(char const*, char const*, unsigned int, unsigned int, unsigned int)"},
-    {"_ZN4llvm20MCAsmParserExtension15HandleDirectiveIN12_GLOBAL__N_115DarwinAsmParserEXadL_ZNS3_35ParseSectionDirectiveThreadInitFuncENS_9StringRefENS_5SMLocEEEEEbPS0_S4_S5_", "bool llvm::MCAsmParserExtension::HandleDirective<(anonymous namespace)::DarwinAsmParser, &((anonymous namespace)::DarwinAsmParser::ParseSectionDirectiveThreadInitFunc(llvm::StringRef, llvm::SMLoc))>(llvm::MCAsmParserExtension*, llvm::StringRef, llvm::SMLoc)"},
-    {"_ZN4llvm20MCAsmParserExtension15HandleDirectiveIN12_GLOBAL__N_115DarwinAsmParserEXadL_ZNS3_25ParseSectionDirectiveTextENS_9StringRefENS_5SMLocEEEEEbPS0_S4_S5_", "bool llvm::MCAsmParserExtension::HandleDirective<(anonymous namespace)::DarwinAsmParser, &((anonymous namespace)::DarwinAsmParser::ParseSectionDirectiveText(llvm::StringRef, llvm::SMLoc))>(llvm::MCAsmParserExtension*, llvm::StringRef, llvm::SMLoc)"},
-    {"_ZN4llvm20MCAsmParserExtension15HandleDirectiveIN12_GLOBAL__N_115DarwinAsmParserEXadL_ZNS3_26ParseSectionDirectiveTDataENS_9StringRefENS_5SMLocEEEEEbPS0_S4_S5_", "bool llvm::MCAsmParserExtension::HandleDirective<(anonymous namespace)::DarwinAsmParser, &((anonymous namespace)::DarwinAsmParser::ParseSectionDirectiveTData(llvm::StringRef, llvm::SMLoc))>(llvm::MCAsmParserExtension*, llvm::StringRef, llvm::SMLoc)"},
-    {"_ZN4llvm20MCAsmParserExtension15HandleDirectiveIN12_GLOBAL__N_115DarwinAsmParserEXadL_ZNS3_31ParseSectionDirectiveSymbolStubENS_9StringRefENS_5SMLocEEEEEbPS0_S4_S5_", "bool llvm::MCAsmParserExtension::HandleDirective<(anonymous namespace)::DarwinAsmParser, &((anonymous namespace)::DarwinAsmParser::ParseSectionDirectiveSymbolStub(llvm::StringRef, llvm::SMLoc))>(llvm::MCAsmParserExtension*, llvm::StringRef, llvm::SMLoc)"},
-    {"_ZN4llvm20MCAsmParserExtension15HandleDirectiveIN12_GLOBAL__N_115DarwinAsmParserEXadL_ZNS3_31ParseSectionDirectiveStaticDataENS_9StringRefENS_5SMLocEEEEEbPS0_S4_S5_", "bool llvm::MCAsmParserExtension::HandleDirective<(anonymous namespace)::DarwinAsmParser, &((anonymous namespace)::DarwinAsmParser::ParseSectionDirectiveStaticData(llvm::StringRef, llvm::SMLoc))>(llvm::MCAsmParserExtension*, llvm::StringRef, llvm::SMLoc)"},
-    {"_ZN4llvm20MCAsmParserExtension15HandleDirectiveIN12_GLOBAL__N_115DarwinAsmParserEXadL_ZNS3_32ParseSectionDirectiveStaticConstENS_9StringRefENS_5SMLocEEEEEbPS0_S4_S5_", "bool llvm::MCAsmParserExtension::HandleDirective<(anonymous namespace)::DarwinAsmParser, &((anonymous namespace)::DarwinAsmParser::ParseSectionDirectiveStaticConst(llvm::StringRef, llvm::SMLoc))>(llvm::MCAsmParserExtension*, llvm::StringRef, llvm::SMLoc)"},
-    {"_ZN4llvm20MCAsmParserExtension15HandleDirectiveIN12_GLOBAL__N_115DarwinAsmParserEXadL_ZNS3_34ParseSectionDirectivePICSymbolStubENS_9StringRefENS_5SMLocEEEEEbPS0_S4_S5_", "bool llvm::MCAsmParserExtension::HandleDirective<(anonymous namespace)::DarwinAsmParser, &((anonymous namespace)::DarwinAsmParser::ParseSectionDirectivePICSymbolStub(llvm::StringRef, llvm::SMLoc))>(llvm::MCAsmParserExtension*, llvm::StringRef, llvm::SMLoc)"},
-    {"_ZN4llvm20MCAsmParserExtension15HandleDirectiveIN12_GLOBAL__N_115DarwinAsmParserEXadL_ZNS3_32ParseSectionDirectiveObjCSymbolsENS_9StringRefENS_5SMLocEEEEEbPS0_S4_S5_", "bool llvm::MCAsmParserExtension::HandleDirective<(anonymous namespace)::DarwinAsmParser, &((anonymous namespace)::DarwinAsmParser::ParseSectionDirectiveObjCSymbols(llvm::StringRef, llvm::SMLoc))>(llvm::MCAsmParserExtension*, llvm::StringRef, llvm::SMLoc)"},
-    {"_ZN4llvm20MCAsmParserExtension15HandleDirectiveIN12_GLOBAL__N_115DarwinAsmParserEXadL_ZNS3_37ParseSectionDirectiveObjCStringObjectENS_9StringRefENS_5SMLocEEEEEbPS0_S4_S5_", "bool llvm::MCAsmParserExtension::HandleDirective<(anonymous namespace)::DarwinAsmParser, &((anonymous namespace)::DarwinAsmParser::ParseSectionDirectiveObjCStringObject(llvm::StringRef, llvm::SMLoc))>(llvm::MCAsmParserExtension*, llvm::StringRef, llvm::SMLoc)"},
-    {"_ZN4llvm20MCAsmParserExtension15HandleDirectiveIN12_GLOBAL__N_115DarwinAsmParserEXadL_ZNS3_37ParseSectionDirectiveObjCSelectorStrsENS_9StringRefENS_5SMLocEEEEEbPS0_S4_S5_", "bool llvm::MCAsmParserExtension::HandleDirective<(anonymous namespace)::DarwinAsmParser, &((anonymous namespace)::DarwinAsmParser::ParseSectionDirectiveObjCSelectorStrs(llvm::StringRef, llvm::SMLoc))>(llvm::MCAsmParserExtension*, llvm::StringRef, llvm::SMLoc)"},
-    {"_ZN4llvm20MCAsmParserExtension15HandleDirectiveIN12_GLOBAL__N_115DarwinAsmParserEXadL_ZNS3_33ParseSectionDirectiveObjCProtocolENS_9StringRefENS_5SMLocEEEEEbPS0_S4_S5_", "bool llvm::MCAsmParserExtension::HandleDirective<(anonymous namespace)::DarwinAsmParser, &((anonymous namespace)::DarwinAsmParser::ParseSectionDirectiveObjCProtocol(llvm::StringRef, llvm::SMLoc))>(llvm::MCAsmParserExtension*, llvm::StringRef, llvm::SMLoc)"},
-    {"_ZN4llvm20MCAsmParserExtension15HandleDirectiveIN12_GLOBAL__N_115DarwinAsmParserEXadL_ZNS3_35ParseSectionDirectiveObjCModuleInfoENS_9StringRefENS_5SMLocEEEEEbPS0_S4_S5_", "bool llvm::MCAsmParserExtension::HandleDirective<(anonymous namespace)::DarwinAsmParser, &((anonymous namespace)::DarwinAsmParser::ParseSectionDirectiveObjCModuleInfo(llvm::StringRef, llvm::SMLoc))>(llvm::MCAsmParserExtension*, llvm::StringRef, llvm::SMLoc)"},
-    {"_ZN4llvm20MCAsmParserExtension15HandleDirectiveIN12_GLOBAL__N_115DarwinAsmParserEXadL_ZNS3_37ParseSectionDirectiveObjCMethVarTypesENS_9StringRefENS_5SMLocEEEEEbPS0_S4_S5_", "bool llvm::MCAsmParserExtension::HandleDirective<(anonymous namespace)::DarwinAsmParser, &((anonymous namespace)::DarwinAsmParser::ParseSectionDirectiveObjCMethVarTypes(llvm::StringRef, llvm::SMLoc))>(llvm::MCAsmParserExtension*, llvm::StringRef, llvm::SMLoc)"},
-    {"_ZN4llvm20MCAsmParserExtension15HandleDirectiveIN12_GLOBAL__N_115DarwinAsmParserEXadL_ZNS3_37ParseSectionDirectiveObjCMethVarNamesENS_9StringRefENS_5SMLocEEEEEbPS0_S4_S5_", "bool llvm::MCAsmParserExtension::HandleDirective<(anonymous namespace)::DarwinAsmParser, &((anonymous namespace)::DarwinAsmParser::ParseSectionDirectiveObjCMethVarNames(llvm::StringRef, llvm::SMLoc))>(llvm::MCAsmParserExtension*, llvm::StringRef, llvm::SMLoc)"},
-    {"_ZN4llvm20MCAsmParserExtension15HandleDirectiveIN12_GLOBAL__N_115DarwinAsmParserEXadL_ZNS3_34ParseSectionDirectiveObjCMetaClassENS_9StringRefENS_5SMLocEEEEEbPS0_S4_S5_", "bool llvm::MCAsmParserExtension::HandleDirective<(anonymous namespace)::DarwinAsmParser, &((anonymous namespace)::DarwinAsmParser::ParseSectionDirectiveObjCMetaClass(llvm::StringRef, llvm::SMLoc))>(llvm::MCAsmParserExtension*, llvm::StringRef, llvm::SMLoc)"},
-    {"_ZN4llvm20MCAsmParserExtension15HandleDirectiveIN12_GLOBAL__N_115DarwinAsmParserEXadL_ZNS3_36ParseSectionDirectiveObjCMessageRefsENS_9StringRefENS_5SMLocEEEEEbPS0_S4_S5_", "bool llvm::MCAsmParserExtension::HandleDirective<(anonymous namespace)::DarwinAsmParser, &((anonymous namespace)::DarwinAsmParser::ParseSectionDirectiveObjCMessageRefs(llvm::StringRef, llvm::SMLoc))>(llvm::MCAsmParserExtension*, llvm::StringRef, llvm::SMLoc)"},
-    {"_ZN4llvm20MCAsmParserExtension15HandleDirectiveIN12_GLOBAL__N_115DarwinAsmParserEXadL_ZNS3_37ParseSectionDirectiveObjCInstanceVarsENS_9StringRefENS_5SMLocEEEEEbPS0_S4_S5_", "bool llvm::MCAsmParserExtension::HandleDirective<(anonymous namespace)::DarwinAsmParser, &((anonymous namespace)::DarwinAsmParser::ParseSectionDirectiveObjCInstanceVars(llvm::StringRef, llvm::SMLoc))>(llvm::MCAsmParserExtension*, llvm::StringRef, llvm::SMLoc)"},
-    {"_ZN4llvm20MCAsmParserExtension15HandleDirectiveIN12_GLOBAL__N_115DarwinAsmParserEXadL_ZNS3_33ParseSectionDirectiveObjCInstMethENS_9StringRefENS_5SMLocEEEEEbPS0_S4_S5_", "bool llvm::MCAsmParserExtension::HandleDirective<(anonymous namespace)::DarwinAsmParser, &((anonymous namespace)::DarwinAsmParser::ParseSectionDirectiveObjCInstMeth(llvm::StringRef, llvm::SMLoc))>(llvm::MCAsmParserExtension*, llvm::StringRef, llvm::SMLoc)"},
-    {"_ZN4llvm20MCAsmParserExtension15HandleDirectiveIN12_GLOBAL__N_115DarwinAsmParserEXadL_ZNS3_32ParseSectionDirectiveObjCClsRefsENS_9StringRefENS_5SMLocEEEEEbPS0_S4_S5_", "bool llvm::MCAsmParserExtension::HandleDirective<(anonymous namespace)::DarwinAsmParser, &((anonymous namespace)::DarwinAsmParser::ParseSectionDirectiveObjCClsRefs(llvm::StringRef, llvm::SMLoc))>(llvm::MCAsmParserExtension*, llvm::StringRef, llvm::SMLoc)"},
-    {"_ZN4llvm20MCAsmParserExtension15HandleDirectiveIN12_GLOBAL__N_115DarwinAsmParserEXadL_ZNS3_32ParseSectionDirectiveObjCClsMethENS_9StringRefENS_5SMLocEEEEEbPS0_S4_S5_", "bool llvm::MCAsmParserExtension::HandleDirective<(anonymous namespace)::DarwinAsmParser, &((anonymous namespace)::DarwinAsmParser::ParseSectionDirectiveObjCClsMeth(llvm::StringRef, llvm::SMLoc))>(llvm::MCAsmParserExtension*, llvm::StringRef, llvm::SMLoc)"},
-    {"_ZN4llvm20MCAsmParserExtension15HandleDirectiveIN12_GLOBAL__N_115DarwinAsmParserEXadL_ZNS3_34ParseSectionDirectiveObjCClassVarsENS_9StringRefENS_5SMLocEEEEEbPS0_S4_S5_", "bool llvm::MCAsmParserExtension::HandleDirective<(anonymous namespace)::DarwinAsmParser, &((anonymous namespace)::DarwinAsmParser::ParseSectionDirectiveObjCClassVars(llvm::StringRef, llvm::SMLoc))>(llvm::MCAsmParserExtension*, llvm::StringRef, llvm::SMLoc)"},
-    {"_ZN4llvm20MCAsmParserExtension15HandleDirectiveIN12_GLOBAL__N_115DarwinAsmParserEXadL_ZNS3_35ParseSectionDirectiveObjCClassNamesENS_9StringRefENS_5SMLocEEEEEbPS0_S4_S5_", "bool llvm::MCAsmParserExtension::HandleDirective<(anonymous namespace)::DarwinAsmParser, &((anonymous namespace)::DarwinAsmParser::ParseSectionDirectiveObjCClassNames(llvm::StringRef, llvm::SMLoc))>(llvm::MCAsmParserExtension*, llvm::StringRef, llvm::SMLoc)"},
-    {"_ZN4llvm20MCAsmParserExtension15HandleDirectiveIN12_GLOBAL__N_115DarwinAsmParserEXadL_ZNS3_30ParseSectionDirectiveObjCClassENS_9StringRefENS_5SMLocEEEEEbPS0_S4_S5_", "bool llvm::MCAsmParserExtension::HandleDirective<(anonymous namespace)::DarwinAsmParser, &((anonymous namespace)::DarwinAsmParser::ParseSectionDirectiveObjCClass(llvm::StringRef, llvm::SMLoc))>(llvm::MCAsmParserExtension*, llvm::StringRef, llvm::SMLoc)"},
-    {"_ZN4llvm20MCAsmParserExtension15HandleDirectiveIN12_GLOBAL__N_115DarwinAsmParserEXadL_ZNS3_33ParseSectionDirectiveObjCCategoryENS_9StringRefENS_5SMLocEEEEEbPS0_S4_S5_", "bool llvm::MCAsmParserExtension::HandleDirective<(anonymous namespace)::DarwinAsmParser, &((anonymous namespace)::DarwinAsmParser::ParseSectionDirectiveObjCCategory(llvm::StringRef, llvm::SMLoc))>(llvm::MCAsmParserExtension*, llvm::StringRef, llvm::SMLoc)"},
-    {"_ZN4llvm20MCAsmParserExtension15HandleDirectiveIN12_GLOBAL__N_115DarwinAsmParserEXadL_ZNS3_36ParseSectionDirectiveObjCCatInstMethENS_9StringRefENS_5SMLocEEEEEbPS0_S4_S5_", "bool llvm::MCAsmParserExtension::HandleDirective<(anonymous namespace)::DarwinAsmParser, &((anonymous namespace)::DarwinAsmParser::ParseSectionDirectiveObjCCatInstMeth(llvm::StringRef, llvm::SMLoc))>(llvm::MCAsmParserExtension*, llvm::StringRef, llvm::SMLoc)"},
-    {"_ZN4llvm20MCAsmParserExtension15HandleDirectiveIN12_GLOBAL__N_115DarwinAsmParserEXadL_ZNS3_35ParseSectionDirectiveObjCCatClsMethENS_9StringRefENS_5SMLocEEEEEbPS0_S4_S5_", "bool llvm::MCAsmParserExtension::HandleDirective<(anonymous namespace)::DarwinAsmParser, &((anonymous namespace)::DarwinAsmParser::ParseSectionDirectiveObjCCatClsMeth(llvm::StringRef, llvm::SMLoc))>(llvm::MCAsmParserExtension*, llvm::StringRef, llvm::SMLoc)"},
-    {"_ZN4llvm20MCAsmParserExtension15HandleDirectiveIN12_GLOBAL__N_115DarwinAsmParserEXadL_ZNS3_42ParseSectionDirectiveNonLazySymbolPointersENS_9StringRefENS_5SMLocEEEEEbPS0_S4_S5_", "bool llvm::MCAsmParserExtension::HandleDirective<(anonymous namespace)::DarwinAsmParser, &((anonymous namespace)::DarwinAsmParser::ParseSectionDirectiveNonLazySymbolPointers(llvm::StringRef, llvm::SMLoc))>(llvm::MCAsmParserExtension*, llvm::StringRef, llvm::SMLoc)"},
-    {"_ZN4llvm20MCAsmParserExtension15HandleDirectiveIN12_GLOBAL__N_115DarwinAsmParserEXadL_ZNS3_32ParseSectionDirectiveModTermFuncENS_9StringRefENS_5SMLocEEEEEbPS0_S4_S5_", "bool llvm::MCAsmParserExtension::HandleDirective<(anonymous namespace)::DarwinAsmParser, &((anonymous namespace)::DarwinAsmParser::ParseSectionDirectiveModTermFunc(llvm::StringRef, llvm::SMLoc))>(llvm::MCAsmParserExtension*, llvm::StringRef, llvm::SMLoc)"},
-    {"_ZN4llvm20MCAsmParserExtension15HandleDirectiveIN12_GLOBAL__N_115DarwinAsmParserEXadL_ZNS3_32ParseSectionDirectiveModInitFuncENS_9StringRefENS_5SMLocEEEEEbPS0_S4_S5_", "bool llvm::MCAsmParserExtension::HandleDirective<(anonymous namespace)::DarwinAsmParser, &((anonymous namespace)::DarwinAsmParser::ParseSectionDirectiveModInitFunc(llvm::StringRef, llvm::SMLoc))>(llvm::MCAsmParserExtension*, llvm::StringRef, llvm::SMLoc)"},
-    {"_ZN4llvm20MCAsmParserExtension15HandleDirectiveIN12_GLOBAL__N_115DarwinAsmParserEXadL_ZNS3_29ParseSectionDirectiveLiteral8ENS_9StringRefENS_5SMLocEEEEEbPS0_S4_S5_", "bool llvm::MCAsmParserExtension::HandleDirective<(anonymous namespace)::DarwinAsmParser, &((anonymous namespace)::DarwinAsmParser::ParseSectionDirectiveLiteral8(llvm::StringRef, llvm::SMLoc))>(llvm::MCAsmParserExtension*, llvm::StringRef, llvm::SMLoc)"},
-    {"_ZN4llvm20MCAsmParserExtension15HandleDirectiveIN12_GLOBAL__N_115DarwinAsmParserEXadL_ZNS3_29ParseSectionDirectiveLiteral4ENS_9StringRefENS_5SMLocEEEEEbPS0_S4_S5_", "bool llvm::MCAsmParserExtension::HandleDirective<(anonymous namespace)::DarwinAsmParser, &((anonymous namespace)::DarwinAsmParser::ParseSectionDirectiveLiteral4(llvm::StringRef, llvm::SMLoc))>(llvm::MCAsmParserExtension*, llvm::StringRef, llvm::SMLoc)"},
-    {"_ZN4llvm20MCAsmParserExtension15HandleDirectiveIN12_GLOBAL__N_115DarwinAsmParserEXadL_ZNS3_30ParseSectionDirectiveLiteral16ENS_9StringRefENS_5SMLocEEEEEbPS0_S4_S5_", "bool llvm::MCAsmParserExtension::HandleDirective<(anonymous namespace)::DarwinAsmParser, &((anonymous namespace)::DarwinAsmParser::ParseSectionDirectiveLiteral16(llvm::StringRef, llvm::SMLoc))>(llvm::MCAsmParserExtension*, llvm::StringRef, llvm::SMLoc)"},
-    {"_ZN4llvm20MCAsmParserExtension15HandleDirectiveIN12_GLOBAL__N_115DarwinAsmParserEXadL_ZNS3_39ParseSectionDirectiveLazySymbolPointersENS_9StringRefENS_5SMLocEEEEEbPS0_S4_S5_", "bool llvm::MCAsmParserExtension::HandleDirective<(anonymous namespace)::DarwinAsmParser, &((anonymous namespace)::DarwinAsmParser::ParseSectionDirectiveLazySymbolPointers(llvm::StringRef, llvm::SMLoc))>(llvm::MCAsmParserExtension*, llvm::StringRef, llvm::SMLoc)"},
-    {"_ZN4llvm20MCAsmParserExtension15HandleDirectiveIN12_GLOBAL__N_115DarwinAsmParserEXadL_ZNS3_32ParseSectionDirectiveFVMLibInit1ENS_9StringRefENS_5SMLocEEEEEbPS0_S4_S5_", "bool llvm::MCAsmParserExtension::HandleDirective<(anonymous namespace)::DarwinAsmParser, &((anonymous namespace)::DarwinAsmParser::ParseSectionDirectiveFVMLibInit1(llvm::StringRef, llvm::SMLoc))>(llvm::MCAsmParserExtension*, llvm::StringRef, llvm::SMLoc)"},
-    {"_ZN4llvm20MCAsmParserExtension15HandleDirectiveIN12_GLOBAL__N_115DarwinAsmParserEXadL_ZNS3_32ParseSectionDirectiveFVMLibInit0ENS_9StringRefENS_5SMLocEEEEEbPS0_S4_S5_", "bool llvm::MCAsmParserExtension::HandleDirective<(anonymous namespace)::DarwinAsmParser, &((anonymous namespace)::DarwinAsmParser::ParseSectionDirectiveFVMLibInit0(llvm::StringRef, llvm::SMLoc))>(llvm::MCAsmParserExtension*, llvm::StringRef, llvm::SMLoc)"},
-    {"_ZN4llvm20MCAsmParserExtension15HandleDirectiveIN12_GLOBAL__N_115DarwinAsmParserEXadL_ZNS3_25ParseSectionDirectiveDyldENS_9StringRefENS_5SMLocEEEEEbPS0_S4_S5_", "bool llvm::MCAsmParserExtension::HandleDirective<(anonymous namespace)::DarwinAsmParser, &((anonymous namespace)::DarwinAsmParser::ParseSectionDirectiveDyld(llvm::StringRef, llvm::SMLoc))>(llvm::MCAsmParserExtension*, llvm::StringRef, llvm::SMLoc)"},
-    {"_ZN4llvm20MCAsmParserExtension15HandleDirectiveIN12_GLOBAL__N_115DarwinAsmParserEXadL_ZNS3_31ParseSectionDirectiveDestructorENS_9StringRefENS_5SMLocEEEEEbPS0_S4_S5_", "bool llvm::MCAsmParserExtension::HandleDirective<(anonymous namespace)::DarwinAsmParser, &((anonymous namespace)::DarwinAsmParser::ParseSectionDirectiveDestructor(llvm::StringRef, llvm::SMLoc))>(llvm::MCAsmParserExtension*, llvm::StringRef, llvm::SMLoc)"},
-    {"_ZN4llvm20MCAsmParserExtension15HandleDirectiveIN12_GLOBAL__N_115DarwinAsmParserEXadL_ZNS3_25ParseSectionDirectiveDataENS_9StringRefENS_5SMLocEEEEEbPS0_S4_S5_", "bool llvm::MCAsmParserExtension::HandleDirective<(anonymous namespace)::DarwinAsmParser, &((anonymous namespace)::DarwinAsmParser::ParseSectionDirectiveData(llvm::StringRef, llvm::SMLoc))>(llvm::MCAsmParserExtension*, llvm::StringRef, llvm::SMLoc)"},
-    {"_ZN4llvm20MCAsmParserExtension15HandleDirectiveIN12_GLOBAL__N_115DarwinAsmParserEXadL_ZNS3_28ParseSectionDirectiveCStringENS_9StringRefENS_5SMLocEEEEEbPS0_S4_S5_", "bool llvm::MCAsmParserExtension::HandleDirective<(anonymous namespace)::DarwinAsmParser, &((anonymous namespace)::DarwinAsmParser::ParseSectionDirectiveCString(llvm::StringRef, llvm::SMLoc))>(llvm::MCAsmParserExtension*, llvm::StringRef, llvm::SMLoc)"},
-    {"_ZN4llvm20MCAsmParserExtension15HandleDirectiveIN12_GLOBAL__N_115DarwinAsmParserEXadL_ZNS3_32ParseSectionDirectiveConstructorENS_9StringRefENS_5SMLocEEEEEbPS0_S4_S5_", "bool llvm::MCAsmParserExtension::HandleDirective<(anonymous namespace)::DarwinAsmParser, &((anonymous namespace)::DarwinAsmParser::ParseSectionDirectiveConstructor(llvm::StringRef, llvm::SMLoc))>(llvm::MCAsmParserExtension*, llvm::StringRef, llvm::SMLoc)"},
-    {"_ZN4llvm20MCAsmParserExtension15HandleDirectiveIN12_GLOBAL__N_115DarwinAsmParserEXadL_ZNS3_30ParseSectionDirectiveConstDataENS_9StringRefENS_5SMLocEEEEEbPS0_S4_S5_", "bool llvm::MCAsmParserExtension::HandleDirective<(anonymous namespace)::DarwinAsmParser, &((anonymous namespace)::DarwinAsmParser::ParseSectionDirectiveConstData(llvm::StringRef, llvm::SMLoc))>(llvm::MCAsmParserExtension*, llvm::StringRef, llvm::SMLoc)"},
-    {"_ZN4llvm20MCAsmParserExtension15HandleDirectiveIN12_GLOBAL__N_115DarwinAsmParserEXadL_ZNS3_26ParseSectionDirectiveConstENS_9StringRefENS_5SMLocEEEEEbPS0_S4_S5_", "bool llvm::MCAsmParserExtension::HandleDirective<(anonymous namespace)::DarwinAsmParser, &((anonymous namespace)::DarwinAsmParser::ParseSectionDirectiveConst(llvm::StringRef, llvm::SMLoc))>(llvm::MCAsmParserExtension*, llvm::StringRef, llvm::SMLoc)"},
-    {"_ZN4llvm20MCAsmParserExtension15HandleDirectiveIN12_GLOBAL__N_115DarwinAsmParserEXadL_ZNS3_22ParseDirectiveZerofillENS_9StringRefENS_5SMLocEEEEEbPS0_S4_S5_", "bool llvm::MCAsmParserExtension::HandleDirective<(anonymous namespace)::DarwinAsmParser, &((anonymous namespace)::DarwinAsmParser::ParseDirectiveZerofill(llvm::StringRef, llvm::SMLoc))>(llvm::MCAsmParserExtension*, llvm::StringRef, llvm::SMLoc)"},
-    {"_ZN4llvm20MCAsmParserExtension15HandleDirectiveIN12_GLOBAL__N_115DarwinAsmParserEXadL_ZNS3_18ParseDirectiveTBSSENS_9StringRefENS_5SMLocEEEEEbPS0_S4_S5_", "bool llvm::MCAsmParserExtension::HandleDirective<(anonymous namespace)::DarwinAsmParser, &((anonymous namespace)::DarwinAsmParser::ParseDirectiveTBSS(llvm::StringRef, llvm::SMLoc))>(llvm::MCAsmParserExtension*, llvm::StringRef, llvm::SMLoc)"},
-    {"_ZN4llvm20MCAsmParserExtension15HandleDirectiveIN12_GLOBAL__N_115DarwinAsmParserEXadL_ZNS3_28ParseDirectiveSecureLogResetENS_9StringRefENS_5SMLocEEEEEbPS0_S4_S5_", "bool llvm::MCAsmParserExtension::HandleDirective<(anonymous namespace)::DarwinAsmParser, &((anonymous namespace)::DarwinAsmParser::ParseDirectiveSecureLogReset(llvm::StringRef, llvm::SMLoc))>(llvm::MCAsmParserExtension*, llvm::StringRef, llvm::SMLoc)"},
-    {"_ZN4llvm20MCAsmParserExtension15HandleDirectiveIN12_GLOBAL__N_115DarwinAsmParserEXadL_ZNS3_29ParseDirectiveSecureLogUniqueENS_9StringRefENS_5SMLocEEEEEbPS0_S4_S5_", "bool llvm::MCAsmParserExtension::HandleDirective<(anonymous namespace)::DarwinAsmParser, &((anonymous namespace)::DarwinAsmParser::ParseDirectiveSecureLogUnique(llvm::StringRef, llvm::SMLoc))>(llvm::MCAsmParserExtension*, llvm::StringRef, llvm::SMLoc)"},
-    {"_ZN4llvm20MCAsmParserExtension15HandleDirectiveIN12_GLOBAL__N_115DarwinAsmParserEXadL_ZNS3_21ParseDirectiveSectionENS_9StringRefENS_5SMLocEEEEEbPS0_S4_S5_", "bool llvm::MCAsmParserExtension::HandleDirective<(anonymous namespace)::DarwinAsmParser, &((anonymous namespace)::DarwinAsmParser::ParseDirectiveSection(llvm::StringRef, llvm::SMLoc))>(llvm::MCAsmParserExtension*, llvm::StringRef, llvm::SMLoc)"},
-    {"_ZN4llvm20MCAsmParserExtension15HandleDirectiveIN12_GLOBAL__N_115DarwinAsmParserEXadL_ZNS3_24ParseDirectiveDumpOrLoadENS_9StringRefENS_5SMLocEEEEEbPS0_S4_S5_", "bool llvm::MCAsmParserExtension::HandleDirective<(anonymous namespace)::DarwinAsmParser, &((anonymous namespace)::DarwinAsmParser::ParseDirectiveDumpOrLoad(llvm::StringRef, llvm::SMLoc))>(llvm::MCAsmParserExtension*, llvm::StringRef, llvm::SMLoc)"},
-    {"_ZN4llvm20MCAsmParserExtension15HandleDirectiveIN12_GLOBAL__N_115DarwinAsmParserEXadL_ZNS3_35ParseDirectiveSubsectionsViaSymbolsENS_9StringRefENS_5SMLocEEEEEbPS0_S4_S5_", "bool llvm::MCAsmParserExtension::HandleDirective<(anonymous namespace)::DarwinAsmParser, &((anonymous namespace)::DarwinAsmParser::ParseDirectiveSubsectionsViaSymbols(llvm::StringRef, llvm::SMLoc))>(llvm::MCAsmParserExtension*, llvm::StringRef, llvm::SMLoc)"},
-    {"_ZN4llvm20MCAsmParserExtension15HandleDirectiveIN12_GLOBAL__N_115DarwinAsmParserEXadL_ZNS3_18ParseDirectiveLsymENS_9StringRefENS_5SMLocEEEEEbPS0_S4_S5_", "bool llvm::MCAsmParserExtension::HandleDirective<(anonymous namespace)::DarwinAsmParser, &((anonymous namespace)::DarwinAsmParser::ParseDirectiveLsym(llvm::StringRef, llvm::SMLoc))>(llvm::MCAsmParserExtension*, llvm::StringRef, llvm::SMLoc)"},
-    {"_ZN4llvm20MCAsmParserExtension15HandleDirectiveIN12_GLOBAL__N_115DarwinAsmParserEXadL_ZNS3_18ParseDirectiveDescENS_9StringRefENS_5SMLocEEEEEbPS0_S4_S5_", "bool llvm::MCAsmParserExtension::HandleDirective<(anonymous namespace)::DarwinAsmParser, &((anonymous namespace)::DarwinAsmParser::ParseDirectiveDesc(llvm::StringRef, llvm::SMLoc))>(llvm::MCAsmParserExtension*, llvm::StringRef, llvm::SMLoc)"},
+    {"_ZN4llvm20MCAsmParserExtension15HandleDirectiveIN12_GLOBAL__N_115DarwinAsmParserEXadL_ZNS3_35ParseSectionDirectiveThreadInitFuncENS_9StringRefENS_5SMLocEEEEEbPS0_S4_S5_",
+     "bool llvm::MCAsmParserExtension::HandleDirective<(anonymous namespace)::DarwinAsmParser, &(anonymous namespace)::DarwinAsmParser::ParseSectionDirectiveThreadInitFunc(llvm::StringRef, llvm::SMLoc)>(llvm::MCAsmParserExtension*, llvm::StringRef, llvm::SMLoc)"},
+    {"_ZN4llvm20MCAsmParserExtension15HandleDirectiveIN12_GLOBAL__N_115DarwinAsmParserEXadL_ZNS3_25ParseSectionDirectiveTextENS_9StringRefENS_5SMLocEEEEEbPS0_S4_S5_",
+     "bool llvm::MCAsmParserExtension::HandleDirective<(anonymous namespace)::DarwinAsmParser, &(anonymous namespace)::DarwinAsmParser::ParseSectionDirectiveText(llvm::StringRef, llvm::SMLoc)>(llvm::MCAsmParserExtension*, llvm::StringRef, llvm::SMLoc)"},
+    {"_ZN4llvm20MCAsmParserExtension15HandleDirectiveIN12_GLOBAL__N_115DarwinAsmParserEXadL_ZNS3_26ParseSectionDirectiveTDataENS_9StringRefENS_5SMLocEEEEEbPS0_S4_S5_",
+     "bool llvm::MCAsmParserExtension::HandleDirective<(anonymous namespace)::DarwinAsmParser, &(anonymous namespace)::DarwinAsmParser::ParseSectionDirectiveTData(llvm::StringRef, llvm::SMLoc)>(llvm::MCAsmParserExtension*, llvm::StringRef, llvm::SMLoc)"},
+    {"_ZN4llvm20MCAsmParserExtension15HandleDirectiveIN12_GLOBAL__N_115DarwinAsmParserEXadL_ZNS3_31ParseSectionDirectiveSymbolStubENS_9StringRefENS_5SMLocEEEEEbPS0_S4_S5_",
+     "bool llvm::MCAsmParserExtension::HandleDirective<(anonymous namespace)::DarwinAsmParser, &(anonymous namespace)::DarwinAsmParser::ParseSectionDirectiveSymbolStub(llvm::StringRef, llvm::SMLoc)>(llvm::MCAsmParserExtension*, llvm::StringRef, llvm::SMLoc)"},
+    {"_ZN4llvm20MCAsmParserExtension15HandleDirectiveIN12_GLOBAL__N_115DarwinAsmParserEXadL_ZNS3_31ParseSectionDirectiveStaticDataENS_9StringRefENS_5SMLocEEEEEbPS0_S4_S5_",
+     "bool llvm::MCAsmParserExtension::HandleDirective<(anonymous namespace)::DarwinAsmParser, &(anonymous namespace)::DarwinAsmParser::ParseSectionDirectiveStaticData(llvm::StringRef, llvm::SMLoc)>(llvm::MCAsmParserExtension*, llvm::StringRef, llvm::SMLoc)"},
+    {"_ZN4llvm20MCAsmParserExtension15HandleDirectiveIN12_GLOBAL__N_115DarwinAsmParserEXadL_ZNS3_32ParseSectionDirectiveStaticConstENS_9StringRefENS_5SMLocEEEEEbPS0_S4_S5_",
+     "bool llvm::MCAsmParserExtension::HandleDirective<(anonymous namespace)::DarwinAsmParser, &(anonymous namespace)::DarwinAsmParser::ParseSectionDirectiveStaticConst(llvm::StringRef, llvm::SMLoc)>(llvm::MCAsmParserExtension*, llvm::StringRef, llvm::SMLoc)"},
+    {"_ZN4llvm20MCAsmParserExtension15HandleDirectiveIN12_GLOBAL__N_115DarwinAsmParserEXadL_ZNS3_34ParseSectionDirectivePICSymbolStubENS_9StringRefENS_5SMLocEEEEEbPS0_S4_S5_",
+     "bool llvm::MCAsmParserExtension::HandleDirective<(anonymous namespace)::DarwinAsmParser, &(anonymous namespace)::DarwinAsmParser::ParseSectionDirectivePICSymbolStub(llvm::StringRef, llvm::SMLoc)>(llvm::MCAsmParserExtension*, llvm::StringRef, llvm::SMLoc)"},
+    {"_ZN4llvm20MCAsmParserExtension15HandleDirectiveIN12_GLOBAL__N_115DarwinAsmParserEXadL_ZNS3_32ParseSectionDirectiveObjCSymbolsENS_9StringRefENS_5SMLocEEEEEbPS0_S4_S5_",
+     "bool llvm::MCAsmParserExtension::HandleDirective<(anonymous namespace)::DarwinAsmParser, &(anonymous namespace)::DarwinAsmParser::ParseSectionDirectiveObjCSymbols(llvm::StringRef, llvm::SMLoc)>(llvm::MCAsmParserExtension*, llvm::StringRef, llvm::SMLoc)"},
+    {"_ZN4llvm20MCAsmParserExtension15HandleDirectiveIN12_GLOBAL__N_115DarwinAsmParserEXadL_ZNS3_37ParseSectionDirectiveObjCStringObjectENS_9StringRefENS_5SMLocEEEEEbPS0_S4_S5_",
+     "bool llvm::MCAsmParserExtension::HandleDirective<(anonymous namespace)::DarwinAsmParser, &(anonymous namespace)::DarwinAsmParser::ParseSectionDirectiveObjCStringObject(llvm::StringRef, llvm::SMLoc)>(llvm::MCAsmParserExtension*, llvm::StringRef, llvm::SMLoc)"},
+    {"_ZN4llvm20MCAsmParserExtension15HandleDirectiveIN12_GLOBAL__N_115DarwinAsmParserEXadL_ZNS3_37ParseSectionDirectiveObjCSelectorStrsENS_9StringRefENS_5SMLocEEEEEbPS0_S4_S5_",
+     "bool llvm::MCAsmParserExtension::HandleDirective<(anonymous namespace)::DarwinAsmParser, &(anonymous namespace)::DarwinAsmParser::ParseSectionDirectiveObjCSelectorStrs(llvm::StringRef, llvm::SMLoc)>(llvm::MCAsmParserExtension*, llvm::StringRef, llvm::SMLoc)"},
+    {"_ZN4llvm20MCAsmParserExtension15HandleDirectiveIN12_GLOBAL__N_115DarwinAsmParserEXadL_ZNS3_33ParseSectionDirectiveObjCProtocolENS_9StringRefENS_5SMLocEEEEEbPS0_S4_S5_",
+     "bool llvm::MCAsmParserExtension::HandleDirective<(anonymous namespace)::DarwinAsmParser, &(anonymous namespace)::DarwinAsmParser::ParseSectionDirectiveObjCProtocol(llvm::StringRef, llvm::SMLoc)>(llvm::MCAsmParserExtension*, llvm::StringRef, llvm::SMLoc)"},
+    {"_ZN4llvm20MCAsmParserExtension15HandleDirectiveIN12_GLOBAL__N_115DarwinAsmParserEXadL_ZNS3_35ParseSectionDirectiveObjCModuleInfoENS_9StringRefENS_5SMLocEEEEEbPS0_S4_S5_",
+     "bool llvm::MCAsmParserExtension::HandleDirective<(anonymous namespace)::DarwinAsmParser, &(anonymous namespace)::DarwinAsmParser::ParseSectionDirectiveObjCModuleInfo(llvm::StringRef, llvm::SMLoc)>(llvm::MCAsmParserExtension*, llvm::StringRef, llvm::SMLoc)"},
+    {"_ZN4llvm20MCAsmParserExtension15HandleDirectiveIN12_GLOBAL__N_115DarwinAsmParserEXadL_ZNS3_37ParseSectionDirectiveObjCMethVarTypesENS_9StringRefENS_5SMLocEEEEEbPS0_S4_S5_",
+     "bool llvm::MCAsmParserExtension::HandleDirective<(anonymous namespace)::DarwinAsmParser, &(anonymous namespace)::DarwinAsmParser::ParseSectionDirectiveObjCMethVarTypes(llvm::StringRef, llvm::SMLoc)>(llvm::MCAsmParserExtension*, llvm::StringRef, llvm::SMLoc)"},
+    {"_ZN4llvm20MCAsmParserExtension15HandleDirectiveIN12_GLOBAL__N_115DarwinAsmParserEXadL_ZNS3_37ParseSectionDirectiveObjCMethVarNamesENS_9StringRefENS_5SMLocEEEEEbPS0_S4_S5_",
+     "bool llvm::MCAsmParserExtension::HandleDirective<(anonymous namespace)::DarwinAsmParser, &(anonymous namespace)::DarwinAsmParser::ParseSectionDirectiveObjCMethVarNames(llvm::StringRef, llvm::SMLoc)>(llvm::MCAsmParserExtension*, llvm::StringRef, llvm::SMLoc)"},
+    {"_ZN4llvm20MCAsmParserExtension15HandleDirectiveIN12_GLOBAL__N_115DarwinAsmParserEXadL_ZNS3_34ParseSectionDirectiveObjCMetaClassENS_9StringRefENS_5SMLocEEEEEbPS0_S4_S5_",
+     "bool llvm::MCAsmParserExtension::HandleDirective<(anonymous namespace)::DarwinAsmParser, &(anonymous namespace)::DarwinAsmParser::ParseSectionDirectiveObjCMetaClass(llvm::StringRef, llvm::SMLoc)>(llvm::MCAsmParserExtension*, llvm::StringRef, llvm::SMLoc)"},
+    {"_ZN4llvm20MCAsmParserExtension15HandleDirectiveIN12_GLOBAL__N_115DarwinAsmParserEXadL_ZNS3_36ParseSectionDirectiveObjCMessageRefsENS_9StringRefENS_5SMLocEEEEEbPS0_S4_S5_",
+     "bool llvm::MCAsmParserExtension::HandleDirective<(anonymous namespace)::DarwinAsmParser, &(anonymous namespace)::DarwinAsmParser::ParseSectionDirectiveObjCMessageRefs(llvm::StringRef, llvm::SMLoc)>(llvm::MCAsmParserExtension*, llvm::StringRef, llvm::SMLoc)"},
+    {"_ZN4llvm20MCAsmParserExtension15HandleDirectiveIN12_GLOBAL__N_115DarwinAsmParserEXadL_ZNS3_37ParseSectionDirectiveObjCInstanceVarsENS_9StringRefENS_5SMLocEEEEEbPS0_S4_S5_",
+     "bool llvm::MCAsmParserExtension::HandleDirective<(anonymous namespace)::DarwinAsmParser, &(anonymous namespace)::DarwinAsmParser::ParseSectionDirectiveObjCInstanceVars(llvm::StringRef, llvm::SMLoc)>(llvm::MCAsmParserExtension*, llvm::StringRef, llvm::SMLoc)"},
+    {"_ZN4llvm20MCAsmParserExtension15HandleDirectiveIN12_GLOBAL__N_115DarwinAsmParserEXadL_ZNS3_33ParseSectionDirectiveObjCInstMethENS_9StringRefENS_5SMLocEEEEEbPS0_S4_S5_",
+     "bool llvm::MCAsmParserExtension::HandleDirective<(anonymous namespace)::DarwinAsmParser, &(anonymous namespace)::DarwinAsmParser::ParseSectionDirectiveObjCInstMeth(llvm::StringRef, llvm::SMLoc)>(llvm::MCAsmParserExtension*, llvm::StringRef, llvm::SMLoc)"},
+    {"_ZN4llvm20MCAsmParserExtension15HandleDirectiveIN12_GLOBAL__N_115DarwinAsmParserEXadL_ZNS3_32ParseSectionDirectiveObjCClsRefsENS_9StringRefENS_5SMLocEEEEEbPS0_S4_S5_",
+     "bool llvm::MCAsmParserExtension::HandleDirective<(anonymous namespace)::DarwinAsmParser, &(anonymous namespace)::DarwinAsmParser::ParseSectionDirectiveObjCClsRefs(llvm::StringRef, llvm::SMLoc)>(llvm::MCAsmParserExtension*, llvm::StringRef, llvm::SMLoc)"},
+    {"_ZN4llvm20MCAsmParserExtension15HandleDirectiveIN12_GLOBAL__N_115DarwinAsmParserEXadL_ZNS3_32ParseSectionDirectiveObjCClsMethENS_9StringRefENS_5SMLocEEEEEbPS0_S4_S5_",
+     "bool llvm::MCAsmParserExtension::HandleDirective<(anonymous namespace)::DarwinAsmParser, &(anonymous namespace)::DarwinAsmParser::ParseSectionDirectiveObjCClsMeth(llvm::StringRef, llvm::SMLoc)>(llvm::MCAsmParserExtension*, llvm::StringRef, llvm::SMLoc)"},
+    {"_ZN4llvm20MCAsmParserExtension15HandleDirectiveIN12_GLOBAL__N_115DarwinAsmParserEXadL_ZNS3_34ParseSectionDirectiveObjCClassVarsENS_9StringRefENS_5SMLocEEEEEbPS0_S4_S5_",
+     "bool llvm::MCAsmParserExtension::HandleDirective<(anonymous namespace)::DarwinAsmParser, &(anonymous namespace)::DarwinAsmParser::ParseSectionDirectiveObjCClassVars(llvm::StringRef, llvm::SMLoc)>(llvm::MCAsmParserExtension*, llvm::StringRef, llvm::SMLoc)"},
+    {"_ZN4llvm20MCAsmParserExtension15HandleDirectiveIN12_GLOBAL__N_115DarwinAsmParserEXadL_ZNS3_35ParseSectionDirectiveObjCClassNamesENS_9StringRefENS_5SMLocEEEEEbPS0_S4_S5_",
+     "bool llvm::MCAsmParserExtension::HandleDirective<(anonymous namespace)::DarwinAsmParser, &(anonymous namespace)::DarwinAsmParser::ParseSectionDirectiveObjCClassNames(llvm::StringRef, llvm::SMLoc)>(llvm::MCAsmParserExtension*, llvm::StringRef, llvm::SMLoc)"},
+    {"_ZN4llvm20MCAsmParserExtension15HandleDirectiveIN12_GLOBAL__N_115DarwinAsmParserEXadL_ZNS3_30ParseSectionDirectiveObjCClassENS_9StringRefENS_5SMLocEEEEEbPS0_S4_S5_",
+     "bool llvm::MCAsmParserExtension::HandleDirective<(anonymous namespace)::DarwinAsmParser, &(anonymous namespace)::DarwinAsmParser::ParseSectionDirectiveObjCClass(llvm::StringRef, llvm::SMLoc)>(llvm::MCAsmParserExtension*, llvm::StringRef, llvm::SMLoc)"},
+    {"_ZN4llvm20MCAsmParserExtension15HandleDirectiveIN12_GLOBAL__N_115DarwinAsmParserEXadL_ZNS3_33ParseSectionDirectiveObjCCategoryENS_9StringRefENS_5SMLocEEEEEbPS0_S4_S5_",
+     "bool llvm::MCAsmParserExtension::HandleDirective<(anonymous namespace)::DarwinAsmParser, &(anonymous namespace)::DarwinAsmParser::ParseSectionDirectiveObjCCategory(llvm::StringRef, llvm::SMLoc)>(llvm::MCAsmParserExtension*, llvm::StringRef, llvm::SMLoc)"},
+    {"_ZN4llvm20MCAsmParserExtension15HandleDirectiveIN12_GLOBAL__N_115DarwinAsmParserEXadL_ZNS3_36ParseSectionDirectiveObjCCatInstMethENS_9StringRefENS_5SMLocEEEEEbPS0_S4_S5_",
+     "bool llvm::MCAsmParserExtension::HandleDirective<(anonymous namespace)::DarwinAsmParser, &(anonymous namespace)::DarwinAsmParser::ParseSectionDirectiveObjCCatInstMeth(llvm::StringRef, llvm::SMLoc)>(llvm::MCAsmParserExtension*, llvm::StringRef, llvm::SMLoc)"},
+    {"_ZN4llvm20MCAsmParserExtension15HandleDirectiveIN12_GLOBAL__N_115DarwinAsmParserEXadL_ZNS3_35ParseSectionDirectiveObjCCatClsMethENS_9StringRefENS_5SMLocEEEEEbPS0_S4_S5_",
+     "bool llvm::MCAsmParserExtension::HandleDirective<(anonymous namespace)::DarwinAsmParser, &(anonymous namespace)::DarwinAsmParser::ParseSectionDirectiveObjCCatClsMeth(llvm::StringRef, llvm::SMLoc)>(llvm::MCAsmParserExtension*, llvm::StringRef, llvm::SMLoc)"},
+    {"_ZN4llvm20MCAsmParserExtension15HandleDirectiveIN12_GLOBAL__N_115DarwinAsmParserEXadL_ZNS3_42ParseSectionDirectiveNonLazySymbolPointersENS_9StringRefENS_5SMLocEEEEEbPS0_S4_S5_",
+     "bool llvm::MCAsmParserExtension::HandleDirective<(anonymous namespace)::DarwinAsmParser, &(anonymous namespace)::DarwinAsmParser::ParseSectionDirectiveNonLazySymbolPointers(llvm::StringRef, llvm::SMLoc)>(llvm::MCAsmParserExtension*, llvm::StringRef, llvm::SMLoc)"},
+    {"_ZN4llvm20MCAsmParserExtension15HandleDirectiveIN12_GLOBAL__N_115DarwinAsmParserEXadL_ZNS3_32ParseSectionDirectiveModTermFuncENS_9StringRefENS_5SMLocEEEEEbPS0_S4_S5_",
+     "bool llvm::MCAsmParserExtension::HandleDirective<(anonymous namespace)::DarwinAsmParser, &(anonymous namespace)::DarwinAsmParser::ParseSectionDirectiveModTermFunc(llvm::StringRef, llvm::SMLoc)>(llvm::MCAsmParserExtension*, llvm::StringRef, llvm::SMLoc)"},
+    {"_ZN4llvm20MCAsmParserExtension15HandleDirectiveIN12_GLOBAL__N_115DarwinAsmParserEXadL_ZNS3_32ParseSectionDirectiveModInitFuncENS_9StringRefENS_5SMLocEEEEEbPS0_S4_S5_",
+     "bool llvm::MCAsmParserExtension::HandleDirective<(anonymous namespace)::DarwinAsmParser, &(anonymous namespace)::DarwinAsmParser::ParseSectionDirectiveModInitFunc(llvm::StringRef, llvm::SMLoc)>(llvm::MCAsmParserExtension*, llvm::StringRef, llvm::SMLoc)"},
+    {"_ZN4llvm20MCAsmParserExtension15HandleDirectiveIN12_GLOBAL__N_115DarwinAsmParserEXadL_ZNS3_29ParseSectionDirectiveLiteral8ENS_9StringRefENS_5SMLocEEEEEbPS0_S4_S5_",
+     "bool llvm::MCAsmParserExtension::HandleDirective<(anonymous namespace)::DarwinAsmParser, &(anonymous namespace)::DarwinAsmParser::ParseSectionDirectiveLiteral8(llvm::StringRef, llvm::SMLoc)>(llvm::MCAsmParserExtension*, llvm::StringRef, llvm::SMLoc)"},
+    {"_ZN4llvm20MCAsmParserExtension15HandleDirectiveIN12_GLOBAL__N_115DarwinAsmParserEXadL_ZNS3_29ParseSectionDirectiveLiteral4ENS_9StringRefENS_5SMLocEEEEEbPS0_S4_S5_",
+     "bool llvm::MCAsmParserExtension::HandleDirective<(anonymous namespace)::DarwinAsmParser, &(anonymous namespace)::DarwinAsmParser::ParseSectionDirectiveLiteral4(llvm::StringRef, llvm::SMLoc)>(llvm::MCAsmParserExtension*, llvm::StringRef, llvm::SMLoc)"},
+    {"_ZN4llvm20MCAsmParserExtension15HandleDirectiveIN12_GLOBAL__N_115DarwinAsmParserEXadL_ZNS3_30ParseSectionDirectiveLiteral16ENS_9StringRefENS_5SMLocEEEEEbPS0_S4_S5_",
+     "bool llvm::MCAsmParserExtension::HandleDirective<(anonymous namespace)::DarwinAsmParser, &(anonymous namespace)::DarwinAsmParser::ParseSectionDirectiveLiteral16(llvm::StringRef, llvm::SMLoc)>(llvm::MCAsmParserExtension*, llvm::StringRef, llvm::SMLoc)"},
+    {"_ZN4llvm20MCAsmParserExtension15HandleDirectiveIN12_GLOBAL__N_115DarwinAsmParserEXadL_ZNS3_39ParseSectionDirectiveLazySymbolPointersENS_9StringRefENS_5SMLocEEEEEbPS0_S4_S5_",
+     "bool llvm::MCAsmParserExtension::HandleDirective<(anonymous namespace)::DarwinAsmParser, &(anonymous namespace)::DarwinAsmParser::ParseSectionDirectiveLazySymbolPointers(llvm::StringRef, llvm::SMLoc)>(llvm::MCAsmParserExtension*, llvm::StringRef, llvm::SMLoc)"},
+    {"_ZN4llvm20MCAsmParserExtension15HandleDirectiveIN12_GLOBAL__N_115DarwinAsmParserEXadL_ZNS3_32ParseSectionDirectiveFVMLibInit1ENS_9StringRefENS_5SMLocEEEEEbPS0_S4_S5_",
+     "bool llvm::MCAsmParserExtension::HandleDirective<(anonymous namespace)::DarwinAsmParser, &(anonymous namespace)::DarwinAsmParser::ParseSectionDirectiveFVMLibInit1(llvm::StringRef, llvm::SMLoc)>(llvm::MCAsmParserExtension*, llvm::StringRef, llvm::SMLoc)"},
+    {"_ZN4llvm20MCAsmParserExtension15HandleDirectiveIN12_GLOBAL__N_115DarwinAsmParserEXadL_ZNS3_32ParseSectionDirectiveFVMLibInit0ENS_9StringRefENS_5SMLocEEEEEbPS0_S4_S5_",
+     "bool llvm::MCAsmParserExtension::HandleDirective<(anonymous namespace)::DarwinAsmParser, &(anonymous namespace)::DarwinAsmParser::ParseSectionDirectiveFVMLibInit0(llvm::StringRef, llvm::SMLoc)>(llvm::MCAsmParserExtension*, llvm::StringRef, llvm::SMLoc)"},
+    {"_ZN4llvm20MCAsmParserExtension15HandleDirectiveIN12_GLOBAL__N_115DarwinAsmParserEXadL_ZNS3_25ParseSectionDirectiveDyldENS_9StringRefENS_5SMLocEEEEEbPS0_S4_S5_",
+     "bool llvm::MCAsmParserExtension::HandleDirective<(anonymous namespace)::DarwinAsmParser, &(anonymous namespace)::DarwinAsmParser::ParseSectionDirectiveDyld(llvm::StringRef, llvm::SMLoc)>(llvm::MCAsmParserExtension*, llvm::StringRef, llvm::SMLoc)"},
+    {"_ZN4llvm20MCAsmParserExtension15HandleDirectiveIN12_GLOBAL__N_115DarwinAsmParserEXadL_ZNS3_31ParseSectionDirectiveDestructorENS_9StringRefENS_5SMLocEEEEEbPS0_S4_S5_",
+     "bool llvm::MCAsmParserExtension::HandleDirective<(anonymous namespace)::DarwinAsmParser, &(anonymous namespace)::DarwinAsmParser::ParseSectionDirectiveDestructor(llvm::StringRef, llvm::SMLoc)>(llvm::MCAsmParserExtension*, llvm::StringRef, llvm::SMLoc)"},
+    {"_ZN4llvm20MCAsmParserExtension15HandleDirectiveIN12_GLOBAL__N_115DarwinAsmParserEXadL_ZNS3_25ParseSectionDirectiveDataENS_9StringRefENS_5SMLocEEEEEbPS0_S4_S5_",
+     "bool llvm::MCAsmParserExtension::HandleDirective<(anonymous namespace)::DarwinAsmParser, &(anonymous namespace)::DarwinAsmParser::ParseSectionDirectiveData(llvm::StringRef, llvm::SMLoc)>(llvm::MCAsmParserExtension*, llvm::StringRef, llvm::SMLoc)"},
+    {"_ZN4llvm20MCAsmParserExtension15HandleDirectiveIN12_GLOBAL__N_115DarwinAsmParserEXadL_ZNS3_28ParseSectionDirectiveCStringENS_9StringRefENS_5SMLocEEEEEbPS0_S4_S5_",
+     "bool llvm::MCAsmParserExtension::HandleDirective<(anonymous namespace)::DarwinAsmParser, &(anonymous namespace)::DarwinAsmParser::ParseSectionDirectiveCString(llvm::StringRef, llvm::SMLoc)>(llvm::MCAsmParserExtension*, llvm::StringRef, llvm::SMLoc)"},
+    {"_ZN4llvm20MCAsmParserExtension15HandleDirectiveIN12_GLOBAL__N_115DarwinAsmParserEXadL_ZNS3_32ParseSectionDirectiveConstructorENS_9StringRefENS_5SMLocEEEEEbPS0_S4_S5_",
+     "bool llvm::MCAsmParserExtension::HandleDirective<(anonymous namespace)::DarwinAsmParser, &(anonymous namespace)::DarwinAsmParser::ParseSectionDirectiveConstructor(llvm::StringRef, llvm::SMLoc)>(llvm::MCAsmParserExtension*, llvm::StringRef, llvm::SMLoc)"},
+    {"_ZN4llvm20MCAsmParserExtension15HandleDirectiveIN12_GLOBAL__N_115DarwinAsmParserEXadL_ZNS3_30ParseSectionDirectiveConstDataENS_9StringRefENS_5SMLocEEEEEbPS0_S4_S5_",
+     "bool llvm::MCAsmParserExtension::HandleDirective<(anonymous namespace)::DarwinAsmParser, &(anonymous namespace)::DarwinAsmParser::ParseSectionDirectiveConstData(llvm::StringRef, llvm::SMLoc)>(llvm::MCAsmParserExtension*, llvm::StringRef, llvm::SMLoc)"},
+    {"_ZN4llvm20MCAsmParserExtension15HandleDirectiveIN12_GLOBAL__N_115DarwinAsmParserEXadL_ZNS3_26ParseSectionDirectiveConstENS_9StringRefENS_5SMLocEEEEEbPS0_S4_S5_",
+     "bool llvm::MCAsmParserExtension::HandleDirective<(anonymous namespace)::DarwinAsmParser, &(anonymous namespace)::DarwinAsmParser::ParseSectionDirectiveConst(llvm::StringRef, llvm::SMLoc)>(llvm::MCAsmParserExtension*, llvm::StringRef, llvm::SMLoc)"},
+    {"_ZN4llvm20MCAsmParserExtension15HandleDirectiveIN12_GLOBAL__N_115DarwinAsmParserEXadL_ZNS3_22ParseDirectiveZerofillENS_9StringRefENS_5SMLocEEEEEbPS0_S4_S5_",
+     "bool llvm::MCAsmParserExtension::HandleDirective<(anonymous namespace)::DarwinAsmParser, &(anonymous namespace)::DarwinAsmParser::ParseDirectiveZerofill(llvm::StringRef, llvm::SMLoc)>(llvm::MCAsmParserExtension*, llvm::StringRef, llvm::SMLoc)"},
+    {"_ZN4llvm20MCAsmParserExtension15HandleDirectiveIN12_GLOBAL__N_115DarwinAsmParserEXadL_ZNS3_18ParseDirectiveTBSSENS_9StringRefENS_5SMLocEEEEEbPS0_S4_S5_",
+     "bool llvm::MCAsmParserExtension::HandleDirective<(anonymous namespace)::DarwinAsmParser, &(anonymous namespace)::DarwinAsmParser::ParseDirectiveTBSS(llvm::StringRef, llvm::SMLoc)>(llvm::MCAsmParserExtension*, llvm::StringRef, llvm::SMLoc)"},
+    {"_ZN4llvm20MCAsmParserExtension15HandleDirectiveIN12_GLOBAL__N_115DarwinAsmParserEXadL_ZNS3_28ParseDirectiveSecureLogResetENS_9StringRefENS_5SMLocEEEEEbPS0_S4_S5_",
+     "bool llvm::MCAsmParserExtension::HandleDirective<(anonymous namespace)::DarwinAsmParser, &(anonymous namespace)::DarwinAsmParser::ParseDirectiveSecureLogReset(llvm::StringRef, llvm::SMLoc)>(llvm::MCAsmParserExtension*, llvm::StringRef, llvm::SMLoc)"},
+    {"_ZN4llvm20MCAsmParserExtension15HandleDirectiveIN12_GLOBAL__N_115DarwinAsmParserEXadL_ZNS3_29ParseDirectiveSecureLogUniqueENS_9StringRefENS_5SMLocEEEEEbPS0_S4_S5_",
+     "bool llvm::MCAsmParserExtension::HandleDirective<(anonymous namespace)::DarwinAsmParser, &(anonymous namespace)::DarwinAsmParser::ParseDirectiveSecureLogUnique(llvm::StringRef, llvm::SMLoc)>(llvm::MCAsmParserExtension*, llvm::StringRef, llvm::SMLoc)"},
+    {"_ZN4llvm20MCAsmParserExtension15HandleDirectiveIN12_GLOBAL__N_115DarwinAsmParserEXadL_ZNS3_21ParseDirectiveSectionENS_9StringRefENS_5SMLocEEEEEbPS0_S4_S5_",
+     "bool llvm::MCAsmParserExtension::HandleDirective<(anonymous namespace)::DarwinAsmParser, &(anonymous namespace)::DarwinAsmParser::ParseDirectiveSection(llvm::StringRef, llvm::SMLoc)>(llvm::MCAsmParserExtension*, llvm::StringRef, llvm::SMLoc)"},
+    {"_ZN4llvm20MCAsmParserExtension15HandleDirectiveIN12_GLOBAL__N_115DarwinAsmParserEXadL_ZNS3_24ParseDirectiveDumpOrLoadENS_9StringRefENS_5SMLocEEEEEbPS0_S4_S5_",
+     "bool llvm::MCAsmParserExtension::HandleDirective<(anonymous namespace)::DarwinAsmParser, &(anonymous namespace)::DarwinAsmParser::ParseDirectiveDumpOrLoad(llvm::StringRef, llvm::SMLoc)>(llvm::MCAsmParserExtension*, llvm::StringRef, llvm::SMLoc)"},
+    {"_ZN4llvm20MCAsmParserExtension15HandleDirectiveIN12_GLOBAL__N_115DarwinAsmParserEXadL_ZNS3_35ParseDirectiveSubsectionsViaSymbolsENS_9StringRefENS_5SMLocEEEEEbPS0_S4_S5_",
+     "bool llvm::MCAsmParserExtension::HandleDirective<(anonymous namespace)::DarwinAsmParser, &(anonymous namespace)::DarwinAsmParser::ParseDirectiveSubsectionsViaSymbols(llvm::StringRef, llvm::SMLoc)>(llvm::MCAsmParserExtension*, llvm::StringRef, llvm::SMLoc)"},
+    {"_ZN4llvm20MCAsmParserExtension15HandleDirectiveIN12_GLOBAL__N_115DarwinAsmParserEXadL_ZNS3_18ParseDirectiveLsymENS_9StringRefENS_5SMLocEEEEEbPS0_S4_S5_",
+     "bool llvm::MCAsmParserExtension::HandleDirective<(anonymous namespace)::DarwinAsmParser, &(anonymous namespace)::DarwinAsmParser::ParseDirectiveLsym(llvm::StringRef, llvm::SMLoc)>(llvm::MCAsmParserExtension*, llvm::StringRef, llvm::SMLoc)"},
+    {"_ZN4llvm20MCAsmParserExtension15HandleDirectiveIN12_GLOBAL__N_115DarwinAsmParserEXadL_ZNS3_18ParseDirectiveDescENS_9StringRefENS_5SMLocEEEEEbPS0_S4_S5_",
+     "bool llvm::MCAsmParserExtension::HandleDirective<(anonymous namespace)::DarwinAsmParser, &(anonymous namespace)::DarwinAsmParser::ParseDirectiveDesc(llvm::StringRef, llvm::SMLoc)>(llvm::MCAsmParserExtension*, llvm::StringRef, llvm::SMLoc)"},
     {"_ZN4llvm18createELFAsmParserEv", "llvm::createELFAsmParser()"},
     {"_ZN12_GLOBAL__N_112ELFAsmParserD1Ev", "(anonymous namespace)::ELFAsmParser::~ELFAsmParser()"},
     {"_ZN12_GLOBAL__N_112ELFAsmParserD0Ev", "(anonymous namespace)::ELFAsmParser::~ELFAsmParser()"},
     {"_ZN12_GLOBAL__N_112ELFAsmParser10InitializeERN4llvm11MCAsmParserE", "(anonymous namespace)::ELFAsmParser::Initialize(llvm::MCAsmParser&)"},
-    {"_ZN4llvm20MCAsmParserExtension15HandleDirectiveIN12_GLOBAL__N_112ELFAsmParserEXadL_ZNS3_21ParseDirectiveWeakrefENS_9StringRefENS_5SMLocEEEEEbPS0_S4_S5_", "bool llvm::MCAsmParserExtension::HandleDirective<(anonymous namespace)::ELFAsmParser, &((anonymous namespace)::ELFAsmParser::ParseDirectiveWeakref(llvm::StringRef, llvm::SMLoc))>(llvm::MCAsmParserExtension*, llvm::StringRef, llvm::SMLoc)"},
-    {"_ZN4llvm20MCAsmParserExtension15HandleDirectiveIN12_GLOBAL__N_112ELFAsmParserEXadL_ZNS3_20ParseDirectiveSymverENS_9StringRefENS_5SMLocEEEEEbPS0_S4_S5_", "bool llvm::MCAsmParserExtension::HandleDirective<(anonymous namespace)::ELFAsmParser, &((anonymous namespace)::ELFAsmParser::ParseDirectiveSymver(llvm::StringRef, llvm::SMLoc))>(llvm::MCAsmParserExtension*, llvm::StringRef, llvm::SMLoc)"},
-    {"_ZN4llvm20MCAsmParserExtension15HandleDirectiveIN12_GLOBAL__N_112ELFAsmParserEXadL_ZNS3_19ParseDirectiveIdentENS_9StringRefENS_5SMLocEEEEEbPS0_S4_S5_", "bool llvm::MCAsmParserExtension::HandleDirective<(anonymous namespace)::ELFAsmParser, &((anonymous namespace)::ELFAsmParser::ParseDirectiveIdent(llvm::StringRef, llvm::SMLoc))>(llvm::MCAsmParserExtension*, llvm::StringRef, llvm::SMLoc)"},
-    {"_ZN4llvm20MCAsmParserExtension15HandleDirectiveIN12_GLOBAL__N_112ELFAsmParserEXadL_ZNS3_18ParseDirectiveTypeENS_9StringRefENS_5SMLocEEEEEbPS0_S4_S5_", "bool llvm::MCAsmParserExtension::HandleDirective<(anonymous namespace)::ELFAsmParser, &((anonymous namespace)::ELFAsmParser::ParseDirectiveType(llvm::StringRef, llvm::SMLoc))>(llvm::MCAsmParserExtension*, llvm::StringRef, llvm::SMLoc)"},
-    {"_ZN4llvm20MCAsmParserExtension15HandleDirectiveIN12_GLOBAL__N_112ELFAsmParserEXadL_ZNS3_22ParseDirectivePreviousENS_9StringRefENS_5SMLocEEEEEbPS0_S4_S5_", "bool llvm::MCAsmParserExtension::HandleDirective<(anonymous namespace)::ELFAsmParser, &((anonymous namespace)::ELFAsmParser::ParseDirectivePrevious(llvm::StringRef, llvm::SMLoc))>(llvm::MCAsmParserExtension*, llvm::StringRef, llvm::SMLoc)"},
-    {"_ZN4llvm20MCAsmParserExtension15HandleDirectiveIN12_GLOBAL__N_112ELFAsmParserEXadL_ZNS3_18ParseDirectiveSizeENS_9StringRefENS_5SMLocEEEEEbPS0_S4_S5_", "bool llvm::MCAsmParserExtension::HandleDirective<(anonymous namespace)::ELFAsmParser, &((anonymous namespace)::ELFAsmParser::ParseDirectiveSize(llvm::StringRef, llvm::SMLoc))>(llvm::MCAsmParserExtension*, llvm::StringRef, llvm::SMLoc)"},
-    {"_ZN4llvm20MCAsmParserExtension15HandleDirectiveIN12_GLOBAL__N_112ELFAsmParserEXadL_ZNS3_21ParseDirectiveSectionENS_9StringRefENS_5SMLocEEEEEbPS0_S4_S5_", "bool llvm::MCAsmParserExtension::HandleDirective<(anonymous namespace)::ELFAsmParser, &((anonymous namespace)::ELFAsmParser::ParseDirectiveSection(llvm::StringRef, llvm::SMLoc))>(llvm::MCAsmParserExtension*, llvm::StringRef, llvm::SMLoc)"},
-    {"_ZN4llvm20MCAsmParserExtension15HandleDirectiveIN12_GLOBAL__N_112ELFAsmParserEXadL_ZNS3_28ParseSectionDirectiveEhFrameENS_9StringRefENS_5SMLocEEEEEbPS0_S4_S5_", "bool llvm::MCAsmParserExtension::HandleDirective<(anonymous namespace)::ELFAsmParser, &((anonymous namespace)::ELFAsmParser::ParseSectionDirectiveEhFrame(llvm::StringRef, llvm::SMLoc))>(llvm::MCAsmParserExtension*, llvm::StringRef, llvm::SMLoc)"},
+    {"_ZN4llvm20MCAsmParserExtension15HandleDirectiveIN12_GLOBAL__N_112ELFAsmParserEXadL_ZNS3_21ParseDirectiveWeakrefENS_9StringRefENS_5SMLocEEEEEbPS0_S4_S5_",
+     "bool llvm::MCAsmParserExtension::HandleDirective<(anonymous namespace)::ELFAsmParser, &(anonymous namespace)::ELFAsmParser::ParseDirectiveWeakref(llvm::StringRef, llvm::SMLoc)>(llvm::MCAsmParserExtension*, llvm::StringRef, llvm::SMLoc)"},
+    {"_ZN4llvm20MCAsmParserExtension15HandleDirectiveIN12_GLOBAL__N_112ELFAsmParserEXadL_ZNS3_20ParseDirectiveSymverENS_9StringRefENS_5SMLocEEEEEbPS0_S4_S5_",
+     "bool llvm::MCAsmParserExtension::HandleDirective<(anonymous namespace)::ELFAsmParser, &(anonymous namespace)::ELFAsmParser::ParseDirectiveSymver(llvm::StringRef, llvm::SMLoc)>(llvm::MCAsmParserExtension*, llvm::StringRef, llvm::SMLoc)"},
+    {"_ZN4llvm20MCAsmParserExtension15HandleDirectiveIN12_GLOBAL__N_112ELFAsmParserEXadL_ZNS3_19ParseDirectiveIdentENS_9StringRefENS_5SMLocEEEEEbPS0_S4_S5_",
+     "bool llvm::MCAsmParserExtension::HandleDirective<(anonymous namespace)::ELFAsmParser, &(anonymous namespace)::ELFAsmParser::ParseDirectiveIdent(llvm::StringRef, llvm::SMLoc)>(llvm::MCAsmParserExtension*, llvm::StringRef, llvm::SMLoc)"},
+    {"_ZN4llvm20MCAsmParserExtension15HandleDirectiveIN12_GLOBAL__N_112ELFAsmParserEXadL_ZNS3_18ParseDirectiveTypeENS_9StringRefENS_5SMLocEEEEEbPS0_S4_S5_",
+     "bool llvm::MCAsmParserExtension::HandleDirective<(anonymous namespace)::ELFAsmParser, &(anonymous namespace)::ELFAsmParser::ParseDirectiveType(llvm::StringRef, llvm::SMLoc)>(llvm::MCAsmParserExtension*, llvm::StringRef, llvm::SMLoc)"},
+    {"_ZN4llvm20MCAsmParserExtension15HandleDirectiveIN12_GLOBAL__N_112ELFAsmParserEXadL_ZNS3_22ParseDirectivePreviousENS_9StringRefENS_5SMLocEEEEEbPS0_S4_S5_",
+     "bool llvm::MCAsmParserExtension::HandleDirective<(anonymous namespace)::ELFAsmParser, &(anonymous namespace)::ELFAsmParser::ParseDirectivePrevious(llvm::StringRef, llvm::SMLoc)>(llvm::MCAsmParserExtension*, llvm::StringRef, llvm::SMLoc)"},
+    {"_ZN4llvm20MCAsmParserExtension15HandleDirectiveIN12_GLOBAL__N_112ELFAsmParserEXadL_ZNS3_18ParseDirectiveSizeENS_9StringRefENS_5SMLocEEEEEbPS0_S4_S5_",
+     "bool llvm::MCAsmParserExtension::HandleDirective<(anonymous namespace)::ELFAsmParser, &(anonymous namespace)::ELFAsmParser::ParseDirectiveSize(llvm::StringRef, llvm::SMLoc)>(llvm::MCAsmParserExtension*, llvm::StringRef, llvm::SMLoc)"},
+    {"_ZN4llvm20MCAsmParserExtension15HandleDirectiveIN12_GLOBAL__N_112ELFAsmParserEXadL_ZNS3_21ParseDirectiveSectionENS_9StringRefENS_5SMLocEEEEEbPS0_S4_S5_",
+     "bool llvm::MCAsmParserExtension::HandleDirective<(anonymous namespace)::ELFAsmParser, &(anonymous namespace)::ELFAsmParser::ParseDirectiveSection(llvm::StringRef, llvm::SMLoc)>(llvm::MCAsmParserExtension*, llvm::StringRef, llvm::SMLoc)"},
+    {"_ZN4llvm20MCAsmParserExtension15HandleDirectiveIN12_GLOBAL__N_112ELFAsmParserEXadL_ZNS3_28ParseSectionDirectiveEhFrameENS_9StringRefENS_5SMLocEEEEEbPS0_S4_S5_",
+     "bool llvm::MCAsmParserExtension::HandleDirective<(anonymous namespace)::ELFAsmParser, &(anonymous namespace)::ELFAsmParser::ParseSectionDirectiveEhFrame(llvm::StringRef, llvm::SMLoc)>(llvm::MCAsmParserExtension*, llvm::StringRef, llvm::SMLoc)"},
     {"_ZN12_GLOBAL__N_112ELFAsmParser18ParseSectionSwitchEN4llvm9StringRefEjjNS1_11SectionKindE", "(anonymous namespace)::ELFAsmParser::ParseSectionSwitch(llvm::StringRef, unsigned int, unsigned int, llvm::SectionKind)"},
-    {"_ZN4llvm20MCAsmParserExtension15HandleDirectiveIN12_GLOBAL__N_112ELFAsmParserEXadL_ZNS3_35ParseSectionDirectiveDataRelRoLocalENS_9StringRefENS_5SMLocEEEEEbPS0_S4_S5_", "bool llvm::MCAsmParserExtension::HandleDirective<(anonymous namespace)::ELFAsmParser, &((anonymous namespace)::ELFAsmParser::ParseSectionDirectiveDataRelRoLocal(llvm::StringRef, llvm::SMLoc))>(llvm::MCAsmParserExtension*, llvm::StringRef, llvm::SMLoc)"},
-    {"_ZN4llvm20MCAsmParserExtension15HandleDirectiveIN12_GLOBAL__N_112ELFAsmParserEXadL_ZNS3_30ParseSectionDirectiveDataRelRoENS_9StringRefENS_5SMLocEEEEEbPS0_S4_S5_", "bool llvm::MCAsmParserExtension::HandleDirective<(anonymous namespace)::ELFAsmParser, &((anonymous namespace)::ELFAsmParser::ParseSectionDirectiveDataRelRo(llvm::StringRef, llvm::SMLoc))>(llvm::MCAsmParserExtension*, llvm::StringRef, llvm::SMLoc)"},
-    {"_ZN4llvm20MCAsmParserExtension15HandleDirectiveIN12_GLOBAL__N_112ELFAsmParserEXadL_ZNS3_28ParseSectionDirectiveDataRelENS_9StringRefENS_5SMLocEEEEEbPS0_S4_S5_", "bool llvm::MCAsmParserExtension::HandleDirective<(anonymous namespace)::ELFAsmParser, &((anonymous namespace)::ELFAsmParser::ParseSectionDirectiveDataRel(llvm::StringRef, llvm::SMLoc))>(llvm::MCAsmParserExtension*, llvm::StringRef, llvm::SMLoc)"},
-    {"_ZN4llvm20MCAsmParserExtension15HandleDirectiveIN12_GLOBAL__N_112ELFAsmParserEXadL_ZNS3_25ParseSectionDirectiveTBSSENS_9StringRefENS_5SMLocEEEEEbPS0_S4_S5_", "bool llvm::MCAsmParserExtension::HandleDirective<(anonymous namespace)::ELFAsmParser, &((anonymous namespace)::ELFAsmParser::ParseSectionDirectiveTBSS(llvm::StringRef, llvm::SMLoc))>(llvm::MCAsmParserExtension*, llvm::StringRef, llvm::SMLoc)"},
-    {"_ZN4llvm20MCAsmParserExtension15HandleDirectiveIN12_GLOBAL__N_112ELFAsmParserEXadL_ZNS3_26ParseSectionDirectiveTDataENS_9StringRefENS_5SMLocEEEEEbPS0_S4_S5_", "bool llvm::MCAsmParserExtension::HandleDirective<(anonymous namespace)::ELFAsmParser, &((anonymous namespace)::ELFAsmParser::ParseSectionDirectiveTData(llvm::StringRef, llvm::SMLoc))>(llvm::MCAsmParserExtension*, llvm::StringRef, llvm::SMLoc)"},
-    {"_ZN4llvm20MCAsmParserExtension15HandleDirectiveIN12_GLOBAL__N_112ELFAsmParserEXadL_ZNS3_27ParseSectionDirectiveRoDataENS_9StringRefENS_5SMLocEEEEEbPS0_S4_S5_", "bool llvm::MCAsmParserExtension::HandleDirective<(anonymous namespace)::ELFAsmParser, &((anonymous namespace)::ELFAsmParser::ParseSectionDirectiveRoData(llvm::StringRef, llvm::SMLoc))>(llvm::MCAsmParserExtension*, llvm::StringRef, llvm::SMLoc)"},
-    {"_ZN4llvm20MCAsmParserExtension15HandleDirectiveIN12_GLOBAL__N_112ELFAsmParserEXadL_ZNS3_24ParseSectionDirectiveBSSENS_9StringRefENS_5SMLocEEEEEbPS0_S4_S5_", "bool llvm::MCAsmParserExtension::HandleDirective<(anonymous namespace)::ELFAsmParser, &((anonymous namespace)::ELFAsmParser::ParseSectionDirectiveBSS(llvm::StringRef, llvm::SMLoc))>(llvm::MCAsmParserExtension*, llvm::StringRef, llvm::SMLoc)"},
-    {"_ZN4llvm20MCAsmParserExtension15HandleDirectiveIN12_GLOBAL__N_112ELFAsmParserEXadL_ZNS3_25ParseSectionDirectiveTextENS_9StringRefENS_5SMLocEEEEEbPS0_S4_S5_", "bool llvm::MCAsmParserExtension::HandleDirective<(anonymous namespace)::ELFAsmParser, &((anonymous namespace)::ELFAsmParser::ParseSectionDirectiveText(llvm::StringRef, llvm::SMLoc))>(llvm::MCAsmParserExtension*, llvm::StringRef, llvm::SMLoc)"},
-    {"_ZN4llvm20MCAsmParserExtension15HandleDirectiveIN12_GLOBAL__N_112ELFAsmParserEXadL_ZNS3_25ParseSectionDirectiveDataENS_9StringRefENS_5SMLocEEEEEbPS0_S4_S5_", "bool llvm::MCAsmParserExtension::HandleDirective<(anonymous namespace)::ELFAsmParser, &((anonymous namespace)::ELFAsmParser::ParseSectionDirectiveData(llvm::StringRef, llvm::SMLoc))>(llvm::MCAsmParserExtension*, llvm::StringRef, llvm::SMLoc)"},
+    {"_ZN4llvm20MCAsmParserExtension15HandleDirectiveIN12_GLOBAL__N_112ELFAsmParserEXadL_ZNS3_35ParseSectionDirectiveDataRelRoLocalENS_9StringRefENS_5SMLocEEEEEbPS0_S4_S5_",
+     "bool llvm::MCAsmParserExtension::HandleDirective<(anonymous namespace)::ELFAsmParser, &(anonymous namespace)::ELFAsmParser::ParseSectionDirectiveDataRelRoLocal(llvm::StringRef, llvm::SMLoc)>(llvm::MCAsmParserExtension*, llvm::StringRef, llvm::SMLoc)"},
+    {"_ZN4llvm20MCAsmParserExtension15HandleDirectiveIN12_GLOBAL__N_112ELFAsmParserEXadL_ZNS3_30ParseSectionDirectiveDataRelRoENS_9StringRefENS_5SMLocEEEEEbPS0_S4_S5_",
+     "bool llvm::MCAsmParserExtension::HandleDirective<(anonymous namespace)::ELFAsmParser, &(anonymous namespace)::ELFAsmParser::ParseSectionDirectiveDataRelRo(llvm::StringRef, llvm::SMLoc)>(llvm::MCAsmParserExtension*, llvm::StringRef, llvm::SMLoc)"},
+    {"_ZN4llvm20MCAsmParserExtension15HandleDirectiveIN12_GLOBAL__N_112ELFAsmParserEXadL_ZNS3_28ParseSectionDirectiveDataRelENS_9StringRefENS_5SMLocEEEEEbPS0_S4_S5_",
+     "bool llvm::MCAsmParserExtension::HandleDirective<(anonymous namespace)::ELFAsmParser, &(anonymous namespace)::ELFAsmParser::ParseSectionDirectiveDataRel(llvm::StringRef, llvm::SMLoc)>(llvm::MCAsmParserExtension*, llvm::StringRef, llvm::SMLoc)"},
+    {"_ZN4llvm20MCAsmParserExtension15HandleDirectiveIN12_GLOBAL__N_112ELFAsmParserEXadL_ZNS3_25ParseSectionDirectiveTBSSENS_9StringRefENS_5SMLocEEEEEbPS0_S4_S5_",
+     "bool llvm::MCAsmParserExtension::HandleDirective<(anonymous namespace)::ELFAsmParser, &(anonymous namespace)::ELFAsmParser::ParseSectionDirectiveTBSS(llvm::StringRef, llvm::SMLoc)>(llvm::MCAsmParserExtension*, llvm::StringRef, llvm::SMLoc)"},
+    {"_ZN4llvm20MCAsmParserExtension15HandleDirectiveIN12_GLOBAL__N_112ELFAsmParserEXadL_ZNS3_26ParseSectionDirectiveTDataENS_9StringRefENS_5SMLocEEEEEbPS0_S4_S5_",
+     "bool llvm::MCAsmParserExtension::HandleDirective<(anonymous namespace)::ELFAsmParser, &(anonymous namespace)::ELFAsmParser::ParseSectionDirectiveTData(llvm::StringRef, llvm::SMLoc)>(llvm::MCAsmParserExtension*, llvm::StringRef, llvm::SMLoc)"},
+    {"_ZN4llvm20MCAsmParserExtension15HandleDirectiveIN12_GLOBAL__N_112ELFAsmParserEXadL_ZNS3_27ParseSectionDirectiveRoDataENS_9StringRefENS_5SMLocEEEEEbPS0_S4_S5_",
+     "bool llvm::MCAsmParserExtension::HandleDirective<(anonymous namespace)::ELFAsmParser, &(anonymous namespace)::ELFAsmParser::ParseSectionDirectiveRoData(llvm::StringRef, llvm::SMLoc)>(llvm::MCAsmParserExtension*, llvm::StringRef, llvm::SMLoc)"},
+    {"_ZN4llvm20MCAsmParserExtension15HandleDirectiveIN12_GLOBAL__N_112ELFAsmParserEXadL_ZNS3_24ParseSectionDirectiveBSSENS_9StringRefENS_5SMLocEEEEEbPS0_S4_S5_",
+     "bool llvm::MCAsmParserExtension::HandleDirective<(anonymous namespace)::ELFAsmParser, &(anonymous namespace)::ELFAsmParser::ParseSectionDirectiveBSS(llvm::StringRef, llvm::SMLoc)>(llvm::MCAsmParserExtension*, llvm::StringRef, llvm::SMLoc)"},
+    {"_ZN4llvm20MCAsmParserExtension15HandleDirectiveIN12_GLOBAL__N_112ELFAsmParserEXadL_ZNS3_25ParseSectionDirectiveTextENS_9StringRefENS_5SMLocEEEEEbPS0_S4_S5_",
+     "bool llvm::MCAsmParserExtension::HandleDirective<(anonymous namespace)::ELFAsmParser, &(anonymous namespace)::ELFAsmParser::ParseSectionDirectiveText(llvm::StringRef, llvm::SMLoc)>(llvm::MCAsmParserExtension*, llvm::StringRef, llvm::SMLoc)"},
+    {"_ZN4llvm20MCAsmParserExtension15HandleDirectiveIN12_GLOBAL__N_112ELFAsmParserEXadL_ZNS3_25ParseSectionDirectiveDataENS_9StringRefENS_5SMLocEEEEEbPS0_S4_S5_",
+     "bool llvm::MCAsmParserExtension::HandleDirective<(anonymous namespace)::ELFAsmParser, &(anonymous namespace)::ELFAsmParser::ParseSectionDirectiveData(llvm::StringRef, llvm::SMLoc)>(llvm::MCAsmParserExtension*, llvm::StringRef, llvm::SMLoc)"},
     {"_ZN4llvm10MCAsmLexerC1Ev", "llvm::MCAsmLexer::MCAsmLexer()"},
     {"_ZN4llvm10MCAsmLexerC2Ev", "llvm::MCAsmLexer::MCAsmLexer()"},
     {"_ZN4llvm10MCAsmLexerD0Ev", "llvm::MCAsmLexer::~MCAsmLexer()"},
     {"_ZN4llvm10MCAsmLexerD1Ev", "llvm::MCAsmLexer::~MCAsmLexer()"},
     {"_ZN4llvm10MCAsmLexerD2Ev", "llvm::MCAsmLexer::~MCAsmLexer()"},
     {"_ZNK4llvm10MCAsmLexer6getLocEv", "llvm::MCAsmLexer::getLoc() const"},
     {"_ZNK4llvm8AsmToken6getLocEv", "llvm::AsmToken::getLoc() const"},
     {"_ZN4llvm11MCAsmParserC1Ev", "llvm::MCAsmParser::MCAsmParser()"},

     {"_ZL12ActiveTimers", "ActiveTimers"},
     {"_ZL11NamedTimers", "NamedTimers"},
     {"_ZL18NamedGroupedTimers", "NamedGroupedTimers"},
     {"_ZL14TimerGroupList", "TimerGroupList"},
     {"_ZL17DefaultTimerGroup", "DefaultTimerGroup"},
     {"_ZL16NotUnderValgrind", "NotUnderValgrind"},
     {"_ZN8Blizzard6Memory12voidp_returncvPT_IcEEv", "Blizzard::Memory::voidp_return::operator char*<char>()"},
     {"_Z2f0PU3AS1c", "f0(char AS1*)"},
-    {"_ZN5Casts8implicitILj4EEEvPN9enable_ifIXleT_Li4EEvE4typeE", "void Casts::implicit<4u>(enable_if<(4u) <= (4), void>::type*)"},
-    {"_ZN5Casts6cstyleILj4EEEvPN9enable_ifIXleT_cvjLi4EEvE4typeE", "void Casts::cstyle<4u>(enable_if<(4u) <= ((unsigned int)(4)), void>::type*)"},
-    {"_ZN5Casts8implicitILj4EEEvPN9enable_ifIXaaT_Li4EEvE4typeE", "void Casts::implicit<4u>(enable_if<(4u) && (4), void>::type*)"},
-    {"_ZN5Casts8implicitILj4EEEvPN9enable_ifIXaNT_Li4EEvE4typeE", "void Casts::implicit<4u>(enable_if<(4u) &= (4), void>::type*)"},
-    {"_ZN5Casts8implicitILj4EEEvPN9enable_ifIXaST_Li4EEvE4typeE", "void Casts::implicit<4u>(enable_if<(4u) = (4), void>::type*)"},
-    {"_ZN5Casts8implicitILj4EEEvPN9enable_ifIXstT_EvE4typeE", "void Casts::implicit<4u>(enable_if<sizeof (4u), void>::type*)"},
-    {"_ZN5Casts8implicitILj4EEEvPN9enable_ifIXszT_EvE4typeE", "void Casts::implicit<4u>(enable_if<sizeof (4u), void>::type*)"},
-    {"_ZN5Casts8implicitILj4EEEvPN9enable_ifIXatT_EvE4typeE", "void Casts::implicit<4u>(enable_if<alignof (4u), void>::type*)"},
-    {"_ZN5Casts8implicitILj4EEEvPN9enable_ifIXazT_EvE4typeE", "void Casts::implicit<4u>(enable_if<alignof (4u), void>::type*)"},
-    {"_ZN5Casts8implicitILj4EEEvPN9enable_ifIXcmT_Li4EEvE4typeE", "void Casts::implicit<4u>(enable_if<(4u) , (4), void>::type*)"},
-    {"_ZN5Casts8implicitILj4EEEvPN9enable_ifIXcoT_EvE4typeE", "void Casts::implicit<4u>(enable_if<~(4u), void>::type*)"},
-    {"_ZN5Casts8implicitILj4EEEvPN9enable_ifIXdeT_EvE4typeE", "void Casts::implicit<4u>(enable_if<*(4u), void>::type*)"},
-    {"_ZN5Casts8implicitILj4EEEvPN9enable_ifIXdvT_Li4EEvE4typeE", "void Casts::implicit<4u>(enable_if<(4u) / (4), void>::type*)"},
-    {"_ZN5Casts8implicitILj4EEEvPN9enable_ifIXdVT_Li4EEvE4typeE", "void Casts::implicit<4u>(enable_if<(4u) /= (4), void>::type*)"},
-    {"_ZN5Casts8implicitILj4EEEvPN9enable_ifIXeoT_Li4EEvE4typeE", "void Casts::implicit<4u>(enable_if<(4u) ^ (4), void>::type*)"},
-    {"_ZN5Casts8implicitILj4EEEvPN9enable_ifIXeOT_Li4EEvE4typeE", "void Casts::implicit<4u>(enable_if<(4u) ^= (4), void>::type*)"},
-    {"_ZN5Casts8implicitILj4EEEvPN9enable_ifIXeqT_Li4EEvE4typeE", "void Casts::implicit<4u>(enable_if<(4u) == (4), void>::type*)"},
-    {"_ZN5Casts8implicitILj4EEEvPN9enable_ifIXgeT_Li4EEvE4typeE", "void Casts::implicit<4u>(enable_if<(4u) >= (4), void>::type*)"},
-    {"_ZN5Casts8implicitILj4EEEvPN9enable_ifIXgtT_Li4EEvE4typeE", "void Casts::implicit<4u>(enable_if<((4u) > (4)), void>::type*)"},
-    {"_ZN5Casts8implicitILj4EEEvPN9enable_ifIXlsT_Li4EEvE4typeE", "void Casts::implicit<4u>(enable_if<(4u) << (4), void>::type*)"},
-    {"_ZN5Casts8implicitILj4EEEvPN9enable_ifIXlST_Li4EEvE4typeE", "void Casts::implicit<4u>(enable_if<(4u) <<= (4), void>::type*)"},
-    {"_ZN5Casts8implicitILj4EEEvPN9enable_ifIXltT_Li4EEvE4typeE", "void Casts::implicit<4u>(enable_if<(4u) < (4), void>::type*)"},
-    {"_ZN5Casts8implicitILj4EEEvPN9enable_ifIXmiT_Li4EEvE4typeE", "void Casts::implicit<4u>(enable_if<(4u) - (4), void>::type*)"},
-    {"_ZN5Casts8implicitILj4EEEvPN9enable_ifIXmIT_Li4EEvE4typeE", "void Casts::implicit<4u>(enable_if<(4u) -= (4), void>::type*)"},
-    {"_ZN5Casts8implicitILj4EEEvPN9enable_ifIXmlT_Li4EEvE4typeE", "void Casts::implicit<4u>(enable_if<(4u) * (4), void>::type*)"},
-    {"_ZN5Casts8implicitILj4EEEvPN9enable_ifIXmLT_Li4EEvE4typeE", "void Casts::implicit<4u>(enable_if<(4u) *= (4), void>::type*)"},
-    {"_ZN5Casts8implicitILj4EEEvPN9enable_ifIXmmT_EvE4typeE", "void Casts::implicit<4u>(enable_if<(4u)--, void>::type*)"},
-    {"_ZN5Casts8implicitILj4EEEvPN9enable_ifIXneT_Li4EEvE4typeE", "void Casts::implicit<4u>(enable_if<(4u) != (4), void>::type*)"},
-    {"_ZN5Casts8implicitILj4EEEvPN9enable_ifIXngT_EvE4typeE", "void Casts::implicit<4u>(enable_if<-(4u), void>::type*)"},
-    {"_ZN5Casts8implicitILj4EEEvPN9enable_ifIXntT_EvE4typeE", "void Casts::implicit<4u>(enable_if<!(4u), void>::type*)"},
-    {"_ZN5Casts8implicitILj4EEEvPN9enable_ifIXooT_Li4EEvE4typeE", "void Casts::implicit<4u>(enable_if<(4u) || (4), void>::type*)"},
-    {"_ZN5Casts8implicitILj4EEEvPN9enable_ifIXorT_Li4EEvE4typeE", "void Casts::implicit<4u>(enable_if<(4u) | (4), void>::type*)"},
-    {"_ZN5Casts8implicitILj4EEEvPN9enable_ifIXoRT_Li4EEvE4typeE", "void Casts::implicit<4u>(enable_if<(4u) |= (4), void>::type*)"},
-    {"_ZN5Casts8implicitILj4EEEvPN9enable_ifIXpmT_Li4EEvE4typeE", "void Casts::implicit<4u>(enable_if<4u->*(4), void>::type*)"},
-    {"_ZN5Casts8implicitILj4EEEvPN9enable_ifIXplT_Li4EEvE4typeE", "void Casts::implicit<4u>(enable_if<(4u) + (4), void>::type*)"},
-    {"_ZN5Casts8implicitILj4EEEvPN9enable_ifIXpLT_Li4EEvE4typeE", "void Casts::implicit<4u>(enable_if<(4u) += (4), void>::type*)"},
-    {"_ZN5Casts8implicitILj4EEEvPN9enable_ifIXppT_EvE4typeE", "void Casts::implicit<4u>(enable_if<(4u)++, void>::type*)"},
-    {"_ZN5Casts8implicitILj4EEEvPN9enable_ifIXpsT_EvE4typeE", "void Casts::implicit<4u>(enable_if<+(4u), void>::type*)"},
-//    {"_ZN5Casts8implicitILj4EEEvPN9enable_ifIXptT_Li4EEvE4typeE", "void Casts::implicit<4u>(enable_if<(4u) -> (4), void>::type*)"},
-    {"_ZN5Casts8implicitILj4EEEvPN9enable_ifIXquT_Li4ELi5EEvE4typeE", "void Casts::implicit<4u>(enable_if<(4u) ? (4) : (5), void>::type*)"},
-    {"_ZN5Casts8implicitILj4EEEvPN9enable_ifIXrmT_Li4EEvE4typeE", "void Casts::implicit<4u>(enable_if<(4u) % (4), void>::type*)"},
-    {"_ZN5Casts8implicitILj4EEEvPN9enable_ifIXrMT_Li4EEvE4typeE", "void Casts::implicit<4u>(enable_if<(4u) %= (4), void>::type*)"},
-    {"_ZN5Casts8implicitILj4EEEvPN9enable_ifIXrsT_Li4EEvE4typeE", "void Casts::implicit<4u>(enable_if<(4u) >> (4), void>::type*)"},
-    {"_ZN5Casts8implicitILj4EEEvPN9enable_ifIXrST_Li4EEvE4typeE", "void Casts::implicit<4u>(enable_if<(4u) >>= (4), void>::type*)"},
-    {"_Z1fPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPP1XS13_S12_S11_S10_SZ_SY_SX_SW_SV_SU_ST_SS_SR_SQ_SP_SO_SN_SM_SL_SK_SJ_SI_SH_SG_SF_SE_SD_SC_SB_SA_S9_S8_S7_S6_S5_S4_S3_S2_S1_S0_S_", "f(X****************************************, X****************************************, X***************************************, X**************************************, X*************************************, X************************************, X***********************************, X**********************************, X*********************************, X********************************, X*******************************, X******************************, X*****************************, X****************************, X***************************, X**************************, X*************************, X************************, X***********************, X**********************, X*********************, X********************, X*******************, X******************, X*****************, X****************, X***************, X**************, X*************, X************, X***********, X**********, X*********, X********, X*******, X******, X*****, X****, X***, X**, X*, X)"},
+    {"_ZN5Casts8implicitILj4EEEvPN9enable_ifIXleT_Li4EEvE4typeE",
+     "void Casts::implicit<4u>(enable_if<4u <= 4, void>::type*)"},
+    {"_ZN5Casts6cstyleILj4EEEvPN9enable_ifIXleT_cvjLi4EEvE4typeE",
+     "void Casts::cstyle<4u>(enable_if<4u <= (unsigned int)(4), void>::type*)"},
+    {"_ZN5Casts8implicitILj4EEEvPN9enable_ifIXaaT_Li4EEvE4typeE",
+     "void Casts::implicit<4u>(enable_if<4u && 4, void>::type*)"},
+    {"_ZN5Casts8implicitILj4EEEvPN9enable_ifIXaNT_Li4EEvE4typeE",
+     "void Casts::implicit<4u>(enable_if<4u &= 4, void>::type*)"},
+    {"_ZN5Casts8implicitILj4EEEvPN9enable_ifIXaST_Li4EEvE4typeE",
+     "void Casts::implicit<4u>(enable_if<4u = 4, void>::type*)"},
+    {"_ZN5Casts8implicitILj4EEEvPN9enable_ifIXstT_EvE4typeE",
+     "void Casts::implicit<4u>(enable_if<sizeof (4u), void>::type*)"},
+    {"_ZN5Casts8implicitILj4EEEvPN9enable_ifIXszT_EvE4typeE",
+     "void Casts::implicit<4u>(enable_if<sizeof (4u), void>::type*)"},
+    {"_ZN5Casts8implicitILj4EEEvPN9enable_ifIXatT_EvE4typeE",
+     "void Casts::implicit<4u>(enable_if<alignof (4u), void>::type*)"},
+    {"_ZN5Casts8implicitILj4EEEvPN9enable_ifIXazT_EvE4typeE",
+     "void Casts::implicit<4u>(enable_if<alignof (4u), void>::type*)"},
+    {"_ZN5Casts8implicitILj4EEEvPN9enable_ifIXcmT_Li4EEvE4typeE",
+     "void Casts::implicit<4u>(enable_if<(4u, 4), void>::type*)"},
+    {"_ZN5Casts8implicitILj4EEEvPN9enable_ifIXplLi1EcmT_Li4EEvE4typeE",
+     "void Casts::implicit<4u>(enable_if<1 + (4u, 4), void>::type*)"},
+    {"_ZN5Casts8implicitILj4EEEvPN9enable_ifIXcoT_EvE4typeE", "void Casts::implicit<4u>(enable_if<~4u, void>::type*)"},
+    {"_ZN5Casts8implicitILj4EEEvPN9enable_ifIXdeT_EvE4typeE", "void Casts::implicit<4u>(enable_if<*4u, void>::type*)"},
+    {"_ZN5Casts8implicitILj4EEEvPN9enable_ifIXdvT_Li4EEvE4typeE",
+     "void Casts::implicit<4u>(enable_if<4u / 4, void>::type*)"},
+    {"_ZN5Casts8implicitILj4EEEvPN9enable_ifIXdVT_Li4EEvE4typeE",
+     "void Casts::implicit<4u>(enable_if<4u /= 4, void>::type*)"},
+    {"_ZN5Casts8implicitILj4EEEvPN9enable_ifIXeoT_Li4EEvE4typeE",
+     "void Casts::implicit<4u>(enable_if<4u ^ 4, void>::type*)"},
+    {"_ZN5Casts8implicitILj4EEEvPN9enable_ifIXeOT_Li4EEvE4typeE",
+     "void Casts::implicit<4u>(enable_if<4u ^= 4, void>::type*)"},
+    {"_ZN5Casts8implicitILj4EEEvPN9enable_ifIXeqT_Li4EEvE4typeE",
+     "void Casts::implicit<4u>(enable_if<4u == 4, void>::type*)"},
+    {"_ZN5Casts8implicitILj4EEEvPN9enable_ifIXgeT_Li4EEvE4typeE",
+     "void Casts::implicit<4u>(enable_if<4u >= 4, void>::type*)"},
+    {"_ZN5Casts8implicitILj4EEEvPN9enable_ifIXgtT_Li4EEvE4typeE",
+     "void Casts::implicit<4u>(enable_if<(4u > 4), void>::type*)"},
+    {"_ZN5Casts8implicitILj4EEEvPN9enable_ifIXngorLi0EgtT_Li4EEvE4typeE",
+     "void Casts::implicit<4u>(enable_if<-(0 | 4u > 4), void>::type*)"},
+    {"_ZN5Casts8implicitILj4EEEvPN9enable_ifIXlsT_Li4EEvE4typeE",
+     "void Casts::implicit<4u>(enable_if<4u << 4, void>::type*)"},
+    {"_ZN5Casts8implicitILj4EEEvPN9enable_ifIXlST_Li4EEvE4typeE",
+     "void Casts::implicit<4u>(enable_if<4u <<= 4, void>::type*)"},
+    {"_ZN5Casts8implicitILj4EEEvPN9enable_ifIXltT_Li4EEvE4typeE",
+     "void Casts::implicit<4u>(enable_if<4u < 4, void>::type*)"},
+    {"_ZN5Casts8implicitILj4EEEvPN9enable_ifIXmiT_Li4EEvE4typeE",
+     "void Casts::implicit<4u>(enable_if<4u - 4, void>::type*)"},
+    {"_ZN5Casts8implicitILj4EEEvPN9enable_ifIXmIT_Li4EEvE4typeE",
+     "void Casts::implicit<4u>(enable_if<4u -= 4, void>::type*)"},
+    {"_ZN5Casts8implicitILj4EEEvPN9enable_ifIXmlT_Li4EEvE4typeE",
+     "void Casts::implicit<4u>(enable_if<4u * 4, void>::type*)"},
+    {"_ZN5Casts8implicitILj4EEEvPN9enable_ifIXmLT_Li4EEvE4typeE",
+     "void Casts::implicit<4u>(enable_if<4u *= 4, void>::type*)"},
+    {"_ZN5Casts8implicitILj4EEEvPN9enable_ifIXmmT_EvE4typeE", "void Casts::implicit<4u>(enable_if<4u--, void>::type*)"},
+    {"_ZN5Casts8implicitILj4EEEvPN9enable_ifIXneT_Li4EEvE4typeE",
+     "void Casts::implicit<4u>(enable_if<4u != 4, void>::type*)"},
+    {"_ZN5Casts8implicitILj4EEEvPN9enable_ifIXngT_EvE4typeE", "void Casts::implicit<4u>(enable_if<-4u, void>::type*)"},
+    {"_ZN5Casts8implicitILj4EEEvPN9enable_ifIXntT_EvE4typeE", "void Casts::implicit<4u>(enable_if<!4u, void>::type*)"},
+    {"_ZN5Casts8implicitILj4EEEvPN9enable_ifIXooT_Li4EEvE4typeE",
+     "void Casts::implicit<4u>(enable_if<4u || 4, void>::type*)"},
+    {"_ZN5Casts8implicitILj4EEEvPN9enable_ifIXorT_Li4EEvE4typeE",
+     "void Casts::implicit<4u>(enable_if<4u | 4, void>::type*)"},
+    {"_ZN5Casts8implicitILj4EEEvPN9enable_ifIXoRT_Li4EEvE4typeE",
+     "void Casts::implicit<4u>(enable_if<4u |= 4, void>::type*)"},
+    {"_ZN5Casts8implicitILj4EEEvPN9enable_ifIXpmT_Li4EEvE4typeE",
+     "void Casts::implicit<4u>(enable_if<4u->*4, void>::type*)"},
+    {"_ZN5Casts8implicitILj4EEEvPN9enable_ifIXplT_Li4EEvE4typeE",
+     "void Casts::implicit<4u>(enable_if<4u + 4, void>::type*)"},
+    {"_ZN5Casts8implicitILj4EEEvPN9enable_ifIXpLT_Li4EEvE4typeE",
+     "void Casts::implicit<4u>(enable_if<4u += 4, void>::type*)"},
+    {"_ZN5Casts8implicitILj4EEEvPN9enable_ifIXppT_EvE4typeE", "void Casts::implicit<4u>(enable_if<4u++, void>::type*)"},
+    {"_ZN5Casts8implicitILj4EEEvPN9enable_ifIXpsT_EvE4typeE", "void Casts::implicit<4u>(enable_if<+4u, void>::type*)"},
+    {"_ZN5Casts8implicitILj4EEEvPN9enable_ifIXptT_Li4EEvE4typeE",
+     "void Casts::implicit<4u>(enable_if<4u->4, void>::type*)"},
+    {"_ZN5Casts8implicitILj4EEEvPN9enable_ifIXquT_Li4ELi5EEvE4typeE",
+     "void Casts::implicit<4u>(enable_if<4u ? 4 : 5, void>::type*)"},
+    {"_ZN5Casts8implicitILj4EEEvPN9enable_ifIXrmT_Li4EEvE4typeE",
+     "void Casts::implicit<4u>(enable_if<4u % 4, void>::type*)"},
+    {"_ZN5Casts8implicitILj4EEEvPN9enable_ifIXrMT_Li4EEvE4typeE",
+     "void Casts::implicit<4u>(enable_if<4u %= 4, void>::type*)"},
+    {"_ZN5Casts8implicitILj4EEEvPN9enable_ifIXrsT_Li4EEvE4typeE",
+     "void Casts::implicit<4u>(enable_if<4u >> 4, void>::type*)"},
+    {"_ZN5Casts8implicitILj4EEEvPN9enable_ifIXrST_Li4EEvE4typeE",
+     "void Casts::implicit<4u>(enable_if<4u >>= 4, void>::type*)"},
+    {"_Z1fPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPP1XS13_S12_S11_S10_SZ_SY_SX_SW_SV_SU_ST_SS_SR_SQ_SP_SO_SN_SM_SL_SK_SJ_"
+     "SI_SH_SG_SF_SE_SD_SC_SB_SA_S9_S8_S7_S6_S5_S4_S3_S2_S1_S0_S_",
+     "f(X****************************************, X****************************************, "
+     "X***************************************, X**************************************, "
+     "X*************************************, X************************************, "
+     "X***********************************, X**********************************, X*********************************, "
+     "X********************************, X*******************************, X******************************, "
+     "X*****************************, X****************************, X***************************, "
+     "X**************************, X*************************, X************************, X***********************, "
+     "X**********************, X*********************, X********************, X*******************, "
+     "X******************, X*****************, X****************, X***************, X**************, X*************, "
+     "X************, X***********, X**********, X*********, X********, X*******, X******, X*****, X****, X***, X**, "
+     "X*, X)"},
     {"_ZZN1J1KEvENK1C1FEv", "J::K()::C::F() const"},
     {"_ZZNVK1J1KEvENK1C1FEv", "J::K() const volatile::C::F() const"},
     {"_Z1fM1AKFvvE", "f(void (A::*)() const)"},
     {"_ZNR1X1fEv", "X::f() &"},
     {"_ZNKO1X1hEv", "X::h() const &&"},
 //    {"_Z1fM1XVKFivEMS_VFivEMS_KOFivE", "f(int (X::*)() const volatile, int (X::*)() volatile, int (X::*)() const &&)"},
 //    {"_Z1fM1XRFivEMS_OFivEMS_KOFivE", "f(int (X::*)() &, int (X::*)() &&, int (X::*)() const &&)"},
     {"_ZN5test12f0ENS_1TILZNS_1xEEEE", "test1::f0(test1::T<test1::x>)"},
     {"_ZN5test12f1ENS_2t1ILZNS_2f0EfEEE", "test1::f1(test1::t1<test1::f0(float)>)"},
-    {"_ZN5test22f1ENS_2t1IXadL_ZNS_2f0EfEEEE", "test2::f1(test2::t1<&(test2::f0(float))>)"},
+    {"_ZN5test22f1ENS_2t1IXadL_ZNS_2f0EfEEEE", "test2::f1(test2::t1<&test2::f0(float)>)"},
     {"_ZN5test32f1ENS_2t1ILZ8test3_f0EEE", "test3::f1(test3::t1<test3_f0>)"},
-    {"_ZN5test42f1ENS_2t1IXadL_Z8test4_f0EEEE", "test4::f1(test4::t1<&(test4_f0)>)"},
+    {"_ZN5test42f1ENS_2t1IXadL_Z8test4_f0EEEE", "test4::f1(test4::t1<&test4_f0>)"},
     {"_ZN5test52f1ENS_2t1ILZ8test5_f0EEE", "test5::f1(test5::t1<test5_f0>)"},
     {"_ZN5test52f2ENS_2t2ILZ4mainEEE", "test5::f2(test5::t2<main>)"},
     {"_ZN5test52f2ENS_2t2ILZ4mainEEE", "test5::f2(test5::t2<main>)"},
-    {"_ZN5test62f0ENS_1TIXadL_ZNS_1A3im0EfEEEE", "test6::f0(test6::T<&(test6::A::im0(float))>)"},
-    {"_ZN5test71XIiEC1IdEEPT_PNS_5int_cIXplL_ZNS_4metaIiE5valueEEsrNS6_IS3_EE5valueEE4typeE", "test7::X<int>::X<double>(double*, test7::int_c<(test7::meta<int>::value) + (test7::meta<double>::value)>::type*)"},
-    {"_ZN5test81fIiEEvNS_5int_cIXsrNS_4metaIT_E4typeE5valueEEE", "void test8::f<int>(test8::int_c<test8::meta<int>::type::value>)"},
-    {"_ZN5test91fIiNS_1XEEENS_9supermetaIT_E5applyIT0_E4typeEv", "test9::supermeta<int>::apply<test9::X>::type test9::f<int, test9::X>()"},
-    {"_ZN6test101fIidEENS_1XIT_E10definitionIT0_EES2_S5_", "test10::X<int>::definition<double> test10::f<int, double>(int, double)"},
+    {"_ZN5test62f0ENS_1TIXadL_ZNS_1A3im0EfEEEE", "test6::f0(test6::T<&test6::A::im0(float)>)"},
+    {"_ZN5test71XIiEC1IdEEPT_PNS_5int_cIXplL_ZNS_4metaIiE5valueEEsrNS6_IS3_EE5valueEE4typeE",
+     "test7::X<int>::X<double>(double*, test7::int_c<test7::meta<int>::value + test7::meta<double>::value>::type*)"},
+    {"_ZN5test81fIiEEvNS_5int_cIXsrNS_4metaIT_E4typeE5valueEEE",
+     "void test8::f<int>(test8::int_c<test8::meta<int>::type::value>)"},
+    {"_ZN5test91fIiNS_1XEEENS_9supermetaIT_E5applyIT0_E4typeEv",
+     "test9::supermeta<int>::apply<test9::X>::type test9::f<int, test9::X>()"},
+    {"_ZN6test101fIidEENS_1XIT_E10definitionIT0_EES2_S5_",
+     "test10::X<int>::definition<double> test10::f<int, double>(int, double)"},
     {"_ZZ2f5vE1a", "f5()::a"},
     {"_ZZ2f6vE1b", "f6()::b"},
     {"_ZNV3$_35test9Ev", "$_3::test9() volatile"},
     {"_ZN5Test8I3$_2EC1ES0_", "Test8<$_2>::Test8($_2)"},
     {"_Z3fooIZN3BarC1EvE3$_0EvT_", "void foo<Bar::Bar()::$_0>(Bar::Bar()::$_0)"},
     {"_ZGVZN1N1gEvE1a", "guard variable for N::g()::a"},
     {"_ZplRK1YRA100_P1X", "operator+(Y const&, X* (&) [100])"},
     {"_Z1fno", "f(__int128, unsigned __int128)"},
     {"_Z1fM1SKFvvE", "f(void (S::*)() const)"},
-    {"_Z3ft7IiEN11__enable_ifIXsr16__is_scalar_typeIT_EE7__valueEvE6__typeEv", "__enable_if<__is_scalar_type<int>::__value, void>::__type ft7<int>()"},
-    {"_Z3ft7IPvEN11__enable_ifIXsr16__is_scalar_typeIT_EE7__valueEvE6__typeEv", "__enable_if<__is_scalar_type<void*>::__value, void>::__type ft7<void*>()"},
-    {"_ZN6PR57968__fill_aIiEENS_11__enable_ifIXntsrNS_11__is_scalarIT_EE7__valueEvE6__typeEv", "PR5796::__enable_if<!(PR5796::__is_scalar<int>::__value), void>::__type PR5796::__fill_a<int>()"},
-    {"_ZN11Expressions2f1ILi1EEEvPAplngT_Li2E_i", "void Expressions::f1<1>(int (*) [(-(1)) + (2)])"},
-    {"_ZN11Expressions2f2ILi1EEEvPApsT__i", "void Expressions::f2<1>(int (*) [+(1)])"},
-    {"_ZN11Expressions2f3ILi1EEEvPAplT_T__i", "void Expressions::f3<1>(int (*) [(1) + (1)])"},
-    {"_ZN11Expressions2f4ILi1EEEvPAplplLi2ET_T__i", "void Expressions::f4<1>(int (*) [((2) + (1)) + (1)])"},
+    {"_Z3ft7IiEN11__enable_ifIXsr16__is_scalar_typeIT_EE7__valueEvE6__typeEv",
+     "__enable_if<__is_scalar_type<int>::__value, void>::__type ft7<int>()"},
+    {"_Z3ft7IPvEN11__enable_ifIXsr16__is_scalar_typeIT_EE7__valueEvE6__typeEv",
+     "__enable_if<__is_scalar_type<void*>::__value, void>::__type ft7<void*>()"},
+    {"_ZN6PR57968__fill_aIiEENS_11__enable_ifIXntsrNS_11__is_scalarIT_EE7__valueEvE6__typeEv",
+     "PR5796::__enable_if<!PR5796::__is_scalar<int>::__value, void>::__type PR5796::__fill_a<int>()"},
+    {"_ZN11Expressions2f1ILi1EEEvPAplngT_Li2E_i", "void Expressions::f1<1>(int (*) [-1 + 2])"},
+    {"_ZN11Expressions2f2ILi1EEEvPApsT__i", "void Expressions::f2<1>(int (*) [+1])"},
+    {"_ZN11Expressions2f3ILi1EEEvPAplT_T__i", "void Expressions::f3<1>(int (*) [1 + 1])"},
+    {"_ZN11Expressions2f4ILi1EEEvPAplplLi2ET_T__i", "void Expressions::f4<1>(int (*) [2 + 1 + 1])"},
+    {"_ZN11Expressions2f4ILi1EEEvPAplLi2EplT_T__i", "void Expressions::f4<1>(int (*) [2 + (1 + 1)])"},
     {"_ZN3OpsplERKS_", "Ops::operator+(Ops const&)"},
     {"_ZN6PR58615AllocIcNS_6PolicyINS_1PELb1EEEE8allocateEiPKv", "PR5861::Alloc<char, PR5861::Policy<PR5861::P, true> >::allocate(int, void const*)"},
     {"_ZN5test01fIdEEvT_RAszcl3ovlcvS1__EE_c", "void test0::f<double>(double, char (&) [sizeof (ovl((double)()))])"},
     {"_ZN5test01fIiEEvT_RAszcl3ovlcvS1__EE_c", "void test0::f<int>(int, char (&) [sizeof (ovl((int)()))])"},
-    {"_ZN5test01jINS_1AEEEvRAszdtcvT__E6buffer_c", "void test0::j<test0::A>(char (&) [sizeof ((test0::A)().buffer)])"},
+    {"_ZN5test01jINS_1AEEEvRAszdtcvT__E6buffer_c",
+     "void test0::j<test0::A>(char (&) [sizeof (((test0::A)()).buffer)])"},
     {"_ZN5test11fINS_1XEiEEvT_IT0_E", "void test1::f<test1::X, int>(test1::X<int>)"},
-    {"_ZN5test211read_memberINS_1AEEEDtptcvPT_Li0E6memberERS2_", "decltype((test2::A*)(0)->member) test2::read_member<test2::A>(test2::A&)"},
-    {"_ZN5test37get_p_1INS_7DerivedEEEDtptcvPT_Li0EsrNS_5Path1E1pERS2_", "decltype((test3::Derived*)(0)->test3::Path1::p) test3::get_p_1<test3::Derived>(test3::Derived&)"},
-    {"_ZN5test37get_p_1INS_7DerivedEEEDtptcvPT_Li0EsrNS_5Path2E1pERS2_", "decltype((test3::Derived*)(0)->test3::Path2::p) test3::get_p_1<test3::Derived>(test3::Derived&)"},
-    {"_ZN5test41gEPNS_3zedIXadL_ZNS_3foo3barEEEEE", "test4::g(test4::zed<&(test4::foo::bar)>*)"},
-    {"_ZN5test51gEPNS_3zedIXadL_ZNS_3foo3barEEEEE", "test5::g(test5::zed<&(test5::foo::bar)>*)"},
-    {"_ZN5test71gEPNS_3zedIXadL_ZNS_3foo3barEvEEEE", "test7::g(test7::zed<&(test7::foo::bar())>*)"},
+    {"_ZN5test211read_memberINS_1AEEEDtptcvPT_Li0E6memberERS2_",
+     "decltype(((test2::A*)(0))->member) test2::read_member<test2::A>(test2::A&)"},
+    {"_ZN5test37get_p_1INS_7DerivedEEEDtptcvPT_Li0EsrNS_5Path1E1pERS2_",
+     "decltype(((test3::Derived*)(0))->test3::Path1::p) test3::get_p_1<test3::Derived>(test3::Derived&)"},
+    {"_ZN5test37get_p_1INS_7DerivedEEEDtptcvPT_Li0EsrNS_5Path2E1pERS2_",
+     "decltype(((test3::Derived*)(0))->test3::Path2::p) test3::get_p_1<test3::Derived>(test3::Derived&)"},
+    {"_ZN5test41gEPNS_3zedIXadL_ZNS_3foo3barEEEEE", "test4::g(test4::zed<&test4::foo::bar>*)"},
+    {"_ZN5test51gEPNS_3zedIXadL_ZNS_3foo3barEEEEE", "test5::g(test5::zed<&test5::foo::bar>*)"},
+    {"_ZN5test71gEPNS_3zedIXadL_ZNS_3foo3barEvEEEE", "test7::g(test7::zed<&test7::foo::bar()>*)"},
     {"_ZN5test91fIiNS_3barEEEvRKNT0_3baz1XE", "void test9::f<int, test9::bar>(test9::bar::baz::X const&)"},
-    {"_ZN6test101fILc3EEEvNS_1SIXquLb0ELc97ET_EEE", "void test10::f<(char)3>(test10::S<(false) ? ((char)97) : ((char)3)>)"},
+    {"_ZN6test101fILc3EEEvNS_1SIXquLb0ELc97ET_EEE", "void test10::f<(char)3>(test10::S<false ? (char)97 : (char)3>)"},
     {"_ZN6test111fEz", "test11::f(...)"},
     {"_ZN6test121fENS_1AILt33000EEE", "test12::f(test12::A<(unsigned short)33000>)"},
-    {"_ZN6test151fILi7EEEvNS_1SIXplT_LNS_1EE3EEEE", "void test15::f<7>(test15::S<(7) + ((test15::E)3)>)"},
-    {"_ZN6test174funcINS_1BEEENS_1AIXszclsrT_3fooEEEEv", "test17::A<sizeof (test17::B::foo())> test17::func<test17::B>()"},
-    {"_ZN6test181fINS_1AEEEvNS_1SIXadsrT_plEEE", "void test18::f<test18::A>(test18::S<&(test18::A::operator+)>)"},
-    {"_ZN6test181fINS_1AEEEvNS_1SIXadsrT_anEEE", "void test18::f<test18::A>(test18::S<&(test18::A::operator&)>)"},
-    {"_ZN6test191gINS_1AEEEvNS_1SIXadsrT_1fIiEEEE", "void test19::g<test19::A>(test19::S<&(test19::A::f<int>)>)"},
-    {"_ZN6test191gINS_1AEEEvNS_1SIXadsrT_plEEE", "void test19::g<test19::A>(test19::S<&(test19::A::operator+)>)"},
-    {"_ZN6test191gINS_1AEEEvNS_1SIXadsrT_cviEEE", "void test19::g<test19::A>(test19::S<&(test19::A::operator int)>)"},
-    {"_ZN6test191gINS_1AEEEvNS_1SIXadsrT_miIdEEEE", "void test19::g<test19::A>(test19::S<&(test19::A::operator-<double>)>)"},
+    {"_ZN6test151fILi7EEEvNS_1SIXplT_LNS_1EE3EEEE", "void test15::f<7>(test15::S<7 + (test15::E)3>)"},
+    {"_ZN6test174funcINS_1BEEENS_1AIXszclsrT_3fooEEEEv",
+     "test17::A<sizeof (test17::B::foo())> test17::func<test17::B>()"},
+    {"_ZN6test181fINS_1AEEEvNS_1SIXadsrT_plEEE", "void test18::f<test18::A>(test18::S<&test18::A::operator+>)"},
+    {"_ZN6test181fINS_1AEEEvNS_1SIXadsrT_anEEE", "void test18::f<test18::A>(test18::S<&test18::A::operator&>)"},
+    {"_ZN6test191gINS_1AEEEvNS_1SIXadsrT_1fIiEEEE", "void test19::g<test19::A>(test19::S<&test19::A::f<int> >)"},
+    {"_ZN6test191gINS_1AEEEvNS_1SIXadsrT_plEEE", "void test19::g<test19::A>(test19::S<&test19::A::operator+>)"},
+    {"_ZN6test191gINS_1AEEEvNS_1SIXadsrT_cviEEE", "void test19::g<test19::A>(test19::S<&test19::A::operator int>)"},
+    {"_ZN6test191gINS_1AEEEvNS_1SIXadsrT_miIdEEEE",
+     "void test19::g<test19::A>(test19::S<&test19::A::operator-<double> >)"},
     {"_ZN6test205test0IiEEvDTcl1fIPT_ELi0EEE", "void test20::test0<int>(decltype(f<int*>(0)))"},
     {"_ZN6test2112vla_arg_funcEiPA_i", "test21::vla_arg_func(int, int (*) [])"},
     {"_ZN6test221fEDn", "test22::f(std::nullptr_t)"},
     {"_ZN6test231fERA10_KPv", "test23::f(void* const (&) [10])"},
     {"_ZN6test231fERA10_A5_VKPv", "test23::f(void* const volatile (&) [10][5])"},
     {"_Z4testIcLj5ELj10ELj15EEvRAT0__AT1__AT2__T_", "void test<char, 5u, 10u, 15u>(char (&) [5u][10u][15u])"},
     {"_ZN6test205test1IiEEvDTcl1fIEcvT__EEE", "void test20::test1<int>(decltype(f<>((int)())))"},
     {"_Z2f0IJEEv1XIXsZT_EJDpRT_EE", "void f0<>(X<sizeof...()>)"},
//    {"_Z1fM1XRFivEMS_OFivEMS_KOFivE", "f(int (X::*)() &, int (X::*)() &&, int (X::*)() const &&)"},
     {"_ZZN4NIds4NStr14TCStrAggregateINS0_13TCTCStrTraitsINS0_11TCStrTraitsIcNS0_17CDefaultStrParamsEEENS0_14TCStrImp_FixedIS5_Lx256EEEEEE21f_AddFromIteratorUTF8INS0_16CStrIteratorUTF8EEEvRxRKT_ENKSA_ISB_EUt0_clEm", "void NIds::NStr::TCStrAggregate<NIds::NStr::TCTCStrTraits<NIds::NStr::TCStrTraits<char, NIds::NStr::CDefaultStrParams>, NIds::NStr::TCStrImp_Fixed<NIds::NStr::TCStrTraits<char, NIds::NStr::CDefaultStrParams>, 256ll> > >::f_AddFromIteratorUTF8<NIds::NStr::CStrIteratorUTF8>(long long&, NIds::NStr::CStrIteratorUTF8 const&)::NIds::NStr::TCStrAggregate<NIds::NStr::TCTCStrTraits<NIds::NStr::TCStrTraits<char, NIds::NStr::CDefaultStrParams>, NIds::NStr::TCStrImp_Fixed<NIds::NStr::TCStrTraits<char, NIds::NStr::CDefaultStrParams>, 256ll> > >::f_AddFromIteratorUTF8<NIds::NStr::CStrIteratorUTF8>::'unnamed0'::operator()(unsigned long) const"},
     {"_ZNK3com9markzware2js11cJSArgumentcvRKT_I8cMyClassEEv", "com::markzware::js::cJSArgument::operator cMyClass const&<cMyClass>() const"},
     {"_ZNKSt3__110__function6__funcIZN4DLCL8DLFutureIP15AnalysenManagerE3setINS_8functionIFS5_vEEEJEEEvT_DpOT0_EUlvE_NS_9allocatorISF_EEFvvEE7__cloneEv", "std::__1::__function::__func<void DLCL::DLFuture<AnalysenManager*>::set<std::__1::function<AnalysenManager* ()> >(std::__1::function<AnalysenManager* ()>)::'lambda'(), std::__1::allocator<void DLCL::DLFuture<AnalysenManager*>::set<std::__1::function<AnalysenManager* ()> >(std::__1::function<AnalysenManager* ()>)::'lambda'()>, void ()>::__clone() const"},
     {"___ZN19URLConnectionClient33_clientInterface_cancelConnectionEP16dispatch_queue_sU13block_pointerFvvE_block_invoke14", "invocation function for block in URLConnectionClient::_clientInterface_cancelConnection(dispatch_queue_s*, void () block_pointer)"},
     {"_Z1fIJicdEEPFvDpT_EPFvDpRPS0_ES8_S1_DpS4_S6_", "void (*f<int, char, double>(void (*)(int*&, char*&, double*&), void (*)(int*&, char*&, double*&), int, char, double, int*, char*, double*, int*&, char*&, double*&))(int, char, double)"},
     {"_ZSteqIcEN9__gnu_cxx11__enable_ifIXsr9__is_charIT_EE7__valueEbE6__typeERKSbIS2_St11char_traitsIS2_ESaIS2_EESA_", "__gnu_cxx::__enable_if<__is_char<char>::__value, bool>::__type std::operator==<char>(std::basic_string<char, std::char_traits<char>, std::allocator<char> > const&, std::basic_string<char, std::char_traits<char>, std::allocator<char> > const&)"},
     {"_ZZ10+[Foo bar]E3Baz", "+[Foo bar]::Baz"},
     {"_ZN9__gnu_cxx17__normal_iteratorIPKSt4pairISsbESt6vectorIS2_SaIS2_EEEC5ERKS4_", "__gnu_cxx::__normal_iterator<std::pair<std::string, bool> const*, std::vector<std::pair<std::string, bool>, std::allocator<std::pair<std::string, bool> > > >::__normal_iterator(std::pair<std::string, bool> const* const&)"},
-    {"_Z1fIiEDTeqfp_LDnEEPT_", "decltype((fp) == (nullptr)) f<int>(int*)"},
-    {"_Z1fIiEDTeqfp1_LDnEEicPT_", "decltype((fp1) == (nullptr)) f<int>(int, char, int*)"},
+    {"_Z1fIiEDTeqfp_LDnEEPT_", "decltype(fp == nullptr) f<int>(int*)"},
+    {"_Z1fIiEDTeqfp1_LDnEEicPT_",
+     "decltype(fp1 == nullptr) f<int>(int, char, int*)"},
     {"_ZZN1S1fEiiEd0_NKUlvE_clEv", "S::f(int, int)::'lambda'()::operator()() const"},
     {"_Z3fooPM2ABi", "foo(int AB::**)"},
     {"_Z1rM1GFivEMS_KFivES_M1HFivES1_4whatIKS_E5what2IS8_ES3_", "r(int (G::*)(), int (G::*)() const, G, int (H::*)(), int (G::*)(), what<G const>, what2<G const>, int (G::*)() const)"},
     {"_Z1fPU11objcproto1A11objc_object", "f(id<A>)"},
     {"_Z1fPKU11objcproto1A7NSArray", "f(NSArray<A> const*)"},
     {"_ZNK1AIJ1Z1Y1XEEcv1BIJDpPT_EEIJS2_S1_S0_EEEv", "A<Z, Y, X>::operator B<X*, Y*, Z*><X, Y, Z>() const"},
     {"_ZNK3Ncr6Silver7Utility6detail12CallOnThreadIZ53-[DeploymentSetupController handleManualServerEntry:]E3$_5EclIJEEEDTclclL_ZNS2_4getTIS4_EERT_vEEspclsr3stdE7forwardIT_Efp_EEEDpOSA_", "decltype(-[DeploymentSetupController handleManualServerEntry:]::$_5& Ncr::Silver::Utility::detail::getT<-[DeploymentSetupController handleManualServerEntry:]::$_5>()()()) Ncr::Silver::Utility::detail::CallOnThread<-[DeploymentSetupController handleManualServerEntry:]::$_5>::operator()<>() const"},
     {"_Zli2_xy", "operator\"\" _x(unsigned long long)"},
//    {"_Z1fM1XRFivEMS_OFivEMS_KOFivE", "f(int (X::*)() &, int (X::*)() &&, int (X::*)() const &&)"},
 
     {"_Z1fIJifcEEvDp5unaryIT_E", "void f<int, float, char>(unary<int>, unary<float>, unary<char>)"},
     {"_Z1fIJEJiEEvDpT_DpT0_", "void f<int>(int)"},
     {"_Z1fIJicEEvDp7MuncherIAstT__S1_E", "void f<int, char>(Muncher<int [sizeof (int)]>, Muncher<char [sizeof (char)]>)"},
     {"_ZN1SIJifcEE1fIJdjEEEiDp4MerpIJifcT_EE", "int S<int, float, char>::f<double, unsigned int>(Merp<int, float, char, double>, Merp<int, float, char, unsigned int>)"},
     {"_Z1pIJicEEiDp4MerpIXsZT_EJT_EE", "int p<int, char>(Merp<sizeof...(int, char), int>, Merp<sizeof...(int, char), char>)"},
 
     // Some expression symbols found in clang's test/CodeGenCXX/mangle-exprs.cpp
-    {"_ZN5Casts8implicitILj4EEEvPN9enable_ifIXleT_Li4EEvE4typeE", "void Casts::implicit<4u>(enable_if<(4u) <= (4), void>::type*)"},
-    {"_ZN5Casts6cstyleILj4EEEvPN9enable_ifIXleT_cvjLi4EEvE4typeE", "void Casts::cstyle<4u>(enable_if<(4u) <= ((unsigned int)(4)), void>::type*)"},
-    {"_ZN5Casts10functionalILj4EEEvPN9enable_ifIXleT_cvjLi4EEvE4typeE", "void Casts::functional<4u>(enable_if<(4u) <= ((unsigned int)(4)), void>::type*)"},
-    {"_ZN5Casts7static_ILj4EEEvPN9enable_ifIXleT_scjLi4EEvE4typeE", "void Casts::static_<4u>(enable_if<(4u) <= (static_cast<unsigned int>(4)), void>::type*)"},
-    {"_ZN5Casts12reinterpret_ILj4EiEEvPN9enable_ifIXleT_szrcPT0_Li0EEvE4typeE", "void Casts::reinterpret_<4u, int>(enable_if<(4u) <= (sizeof (reinterpret_cast<int*>(0))), void>::type*)"},
-    {"_ZN5Casts6const_IiXadL_ZNS_1iEEEEEvPN9enable_ifIXleLi0EszccPT_T0_EvE4typeE", "void Casts::const_<int, &(Casts::i)>(enable_if<(0) <= (sizeof (const_cast<int*>(&(Casts::i)))), void>::type*)"},
-    {"_ZN5Casts8dynamic_INS_1SEXadL_ZNS_1sEEEEEvPN9enable_ifIXleLi0EszdcPT_T0_EvE4typeE", "void Casts::dynamic_<Casts::S, &(Casts::s)>(enable_if<(0) <= (sizeof (dynamic_cast<Casts::S*>(&(Casts::s)))), void>::type*)"},
+    {"_ZN5Casts8implicitILj4EEEvPN9enable_ifIXleT_Li4EEvE4typeE",
+     "void Casts::implicit<4u>(enable_if<4u <= 4, void>::type*)"},
+    {"_ZN5Casts6cstyleILj4EEEvPN9enable_ifIXleT_cvjLi4EEvE4typeE",
+     "void Casts::cstyle<4u>(enable_if<4u <= (unsigned int)(4), void>::type*)"},
+    {"_ZN5Casts10functionalILj4EEEvPN9enable_ifIXleT_cvjLi4EEvE4typeE",
+     "void Casts::functional<4u>(enable_if<4u <= (unsigned int)(4), void>::type*)"},
+    {"_ZN5Casts7static_ILj4EEEvPN9enable_ifIXleT_scjLi4EEvE4typeE",
+     "void Casts::static_<4u>(enable_if<4u <= static_cast<unsigned int>(4), void>::type*)"},
+    {"_ZN5Casts12reinterpret_ILj4EiEEvPN9enable_ifIXleT_szrcPT0_Li0EEvE4typeE",
+     "void Casts::reinterpret_<4u, int>(enable_if<4u <= sizeof (reinterpret_cast<int*>(0)), void>::type*)"},
+    {"_ZN5Casts6const_IiXadL_ZNS_1iEEEEEvPN9enable_ifIXleLi0EszccPT_T0_EvE4typeE",
+     "void Casts::const_<int, &Casts::i>(enable_if<0 <= sizeof (const_cast<int*>(&Casts::i)), void>::type*)"},
+    {"_ZN5Casts8dynamic_INS_1SEXadL_ZNS_1sEEEEEvPN9enable_ifIXleLi0EszdcPT_T0_EvE4typeE",
+     "void Casts::dynamic_<Casts::S, &Casts::s>(enable_if<0 <= sizeof (dynamic_cast<Casts::S*>(&Casts::s)), "
+     "void>::type*)"},
     {"_ZN5Casts1fILi6EEENS_1TIXT_EEEv", "Casts::T<6> Casts::f<6>()"},
     {"_ZN5Casts5auto_IiEEvDTnw_DapicvT__EEE", "void Casts::auto_<int>(decltype(new auto((int)())))"},
-    {"_ZN5Casts7scalar_IiEEvDTcmcvT__Ecvi_EE", "void Casts::scalar_<int>(decltype(((int)()) , ((int)())))"},
+    {"_ZN5Casts7scalar_IiEEvDTcmcvT__Ecvi_EE", "void Casts::scalar_<int>(decltype((int)(), (int)()))"},
     {"_ZN5test11aIsEEDTcl3foocvT__EEES1_", "decltype(foo((short)())) test1::a<short>(short)"},
     {"_ZN5test21aIPFfvEEEvT_DTclfL0p_EE", "void test2::a<float (*)()>(float (*)(), decltype(fp()))"},
     {"_ZN5test21bIPFfvEEEDTclfp_EET_", "decltype(fp()) test2::b<float (*)()>(float (*)())"},
     {"_ZN5test21cIPFfvEEEvT_PFvDTclfL1p_EEE", "void test2::c<float (*)()>(float (*)(), void (*)(decltype(fp())))"},
     {"_ZN5test21dIPFfvEEEvT_PFDTclfL0p_EEvE", "void test2::d<float (*)()>(float (*)(), decltype(fp()) (*)())"},
     {"_ZN5test21eIPFfvEEEvPFDTclfp_EET_E", "void test2::e<float (*)()>(decltype(fp()) (*)(float (*)()))"},
     {"_ZN5test21fIPFfvEEEvPFvT_DTclfL0p_EEE", "void test2::f<float (*)()>(void (*)(float (*)(), decltype(fp())))"},
     {"_ZN5test21gIPFfvEEEvT_DTclfL0p_EE", "void test2::g<float (*)()>(float (*)(), decltype(fp()))"},
     {"_ZN5test21hIPFfvEEEvT_DTcvPFDTclfL0p_EEvELi0EE", "void test2::h<float (*)()>(float (*)(), decltype((decltype(fp()) (*)())(0)))"},
     {"_ZN5test21iIPFfvEEEvDTcvPFDTclfp_EET_ELi0EE", "void test2::i<float (*)()>(decltype((decltype(fp()) (*)(float (*)()))(0)))"},
     {"_ZZN5test21gIPFfvEEEvT_DTclfL0p_EEE8variable", "void test2::g<float (*)()>(float (*)(), decltype(fp()))::variable"},
-    {"_ZN5test31aINS_1XEMS1_PiEEvT_T0_DTdsfL0p_fL0p0_E", "void test3::a<test3::X, int* test3::X::*>(test3::X, int* test3::X::*, decltype(fp.*(fp0)))"},
+    {"_ZN5test31aINS_1XEMS1_PiEEvT_T0_DTdsfL0p_fL0p0_E",
+     "void test3::a<test3::X, int* test3::X::*>(test3::X, int* test3::X::*, decltype(fp.*fp0))"},
     {"_ZN5test43tf1INS_1XEEEvDTnw_T_piLi1EEE", "void test4::tf1<test4::X>(decltype(new test4::X(1)))"},
     {"_ZN5test51aIiEEvDTnxcvT__EE", "void test5::a<int>(decltype(noexcept ((int)())))"},
     {"_ZN5test62f1IiEEvDTcvT_dtdtL_ZNS_1zEE2ua1iE", "void test6::f1<int>(decltype((int)(test6::z.ua.i)))"},
     {"_ZN5test62f2IiEEvDTcvT_dtdtL_ZNS_1zEE2ub1iE", "void test6::f2<int>(decltype((int)(test6::z.ub.i)))"},
     {"_ZN5test62f3IiEEvDTcvT_dtdtL_ZNS_1zEE1s1iE", "void test6::f3<int>(decltype((int)(test6::z.s.i)))"},
     {"_ZN5test62f4IiEEvDTcvT_dtdtL_ZNS_1zEE4uuss1iE", "void test6::f4<int>(decltype((int)(test6::z.uuss.i)))"},
     {"_ZN5test62f5IiEEvDTcvT_dtptL_ZNS_2zpEE2ua1iE", "void test6::f5<int>(decltype((int)(test6::zp->ua.i)))"},
     {"_ZN5test62f6IiEEvDTcvT_dtptL_ZNS_2zpEE2ub1iE", "void test6::f6<int>(decltype((int)(test6::zp->ub.i)))"},
     {"_ZN5test62f7IiEEvDTcvT_dtptL_ZNS_2zpEE1s1iE", "void test6::f7<int>(decltype((int)(test6::zp->s.i)))"},
     {"_ZN5test62f8IiEEvDTcvT_dtptL_ZNS_2zpEE4uuss1iE", "void test6::f8<int>(decltype((int)(test6::zp->uuss.i)))"},
-    {"_ZN5test73fD2IiEEDTcmcvNS_1DEL_ZNS_1bEEcvT__EES2_", "decltype(((test7::D)(test7::b)) , ((int)())) test7::fD2<int>(int)"},
+    {"_ZN5test73fD2IiEEDTcmcvNS_1DEL_ZNS_1bEEcvT__EES2_",
+     "decltype((test7::D)(test7::b), (int)()) test7::fD2<int>(int)"},
     {"_ZN5test73fT2IiEEDTcvT__EES1_", "decltype((int)()) test7::fT2<int>(int)"},
     {"_ZN5test73fT4IiEEDTcvT_Li1EES1_", "decltype((int)(1)) test7::fT4<int>(int)"},
     {"_ZN5test73fT6INS_1BEEEDTcvT__Li1ELi2EEES2_", "decltype((test7::B)(1, 2)) test7::fT6<test7::B>(test7::B)"},
     {"_ZNK5test81XIiE3barIiEEDTcl3fooIT_EEEv", "decltype(foo<int>()) test8::X<int>::bar<int>() const"},
 
     // Multiple qualifiers on the same type should all get the same entry in the substitution table.
     {"_Z1fPU3AS1KiS0_", "f(int const AS1*, int const AS1*)"},
 
     {"_ZN6test471fINS_1SEEEvPTsNT_1cE", "void test47::f<test47::S>(struct test47::S::c*)"},
     {"_ZN6test481fINS_1SEEEvPTuNT_1uE", "void test48::f<test48::S>(union test48::S::u*)"},
     {"_ZN6test451fINS_1SEEEvPTeNT_1eE", "void test45::f<test45::S>(enum test45::S::e*)"},
 
     // String literals
     // FIXME: We need to encode the string contents in order to avoid symbol collisions.
     {"_Z1fIcEvDTcv3StrIT_ELA6_KcEE", "void f<char>(decltype((Str<char>)(\"<char const [6]>\")))"},
 
     // Initializer list expressions
     {"_ZN5test43tf2INS_1XEEEvDTnw_T_piilLi1EEEE", "void test4::tf2<test4::X>(decltype(new test4::X({1})))"},
-    {"_ZN5test73fA1IiEEDTcmtlNS_1AELi1ELi2EEcvT__EES2_", "decltype((test7::A{1, 2}) , ((int)())) test7::fA1<int>(int)"},
-    {"_ZN5test73fA2IiEEDTcmcvNS_1AEilLi1ELi2EEcvT__EES2_", "decltype(((test7::A)({1, 2})) , ((int)())) test7::fA2<int>(int)"},
-    {"_ZN5test73fB1IiEEDTcmtlNS_1BELi1ELi2EEcvT__EES2_", "decltype((test7::B{1, 2}) , ((int)())) test7::fB1<int>(int)"},
-    {"_ZN5test73fB2IiEEDTcmcvNS_1BEilLi1ELi2EEcvT__EES2_", "decltype(((test7::B)({1, 2})) , ((int)())) test7::fB2<int>(int)"},
-    {"_ZN5test73fC1IiEEDTcmtlNS_1CEilLi1ELi2EEEcvT__EES2_", "decltype((test7::C{{1, 2}}) , ((int)())) test7::fC1<int>(int)"},
-    {"_ZN5test73fC2IiEEDTcmcvNS_1CEilLi1ELi2EEcvT__EES2_", "decltype(((test7::C)({1, 2})) , ((int)())) test7::fC2<int>(int)"},
-    {"_ZN5test73fD1IiEEDTcmtlNS_1DEL_ZNS_1bEEEcvT__EES2_", "decltype((test7::D{test7::b}) , ((int)())) test7::fD1<int>(int)"},
-    {"_ZN5test73fE1IiEEDTcmtlNS_1EELi1ELi2EEcvT__EES2_", "decltype((test7::E{1, 2}) , ((int)())) test7::fE1<int>(int)"},
-    {"_ZN5test73fE2IiEEDTcmcvNS_1EEilLi1ELi2EEcvT__EES2_", "decltype(((test7::E)({1, 2})) , ((int)())) test7::fE2<int>(int)"},
-    {"_ZN5test73fF1IiEEDTcmtlNS_1FEilLi1ELi2EEEcvT__EES2_", "decltype((test7::F{{1, 2}}) , ((int)())) test7::fF1<int>(int)"},
-    {"_ZN5test73fF2IiEEDTcmcvNS_1FEilLi1ELi2EEcvT__EES2_", "decltype(((test7::F)({1, 2})) , ((int)())) test7::fF2<int>(int)"},
+    {"_ZN5test73fA1IiEEDTcmtlNS_1AELi1ELi2EEcvT__EES2_", "decltype(test7::A{1, 2}, (int)()) test7::fA1<int>(int)"},
+    {"_ZN5test73fA2IiEEDTcmcvNS_1AEilLi1ELi2EEcvT__EES2_",
+     "decltype((test7::A)({1, 2}), (int)()) test7::fA2<int>(int)"},
+    {"_ZN5test73fB1IiEEDTcmtlNS_1BELi1ELi2EEcvT__EES2_", "decltype(test7::B{1, 2}, (int)()) test7::fB1<int>(int)"},
+    {"_ZN5test73fB2IiEEDTcmcvNS_1BEilLi1ELi2EEcvT__EES2_",
+     "decltype((test7::B)({1, 2}), (int)()) test7::fB2<int>(int)"},
+    {"_ZN5test73fC1IiEEDTcmtlNS_1CEilLi1ELi2EEEcvT__EES2_", "decltype(test7::C{{1, 2}}, (int)()) test7::fC1<int>(int)"},
+    {"_ZN5test73fC2IiEEDTcmcvNS_1CEilLi1ELi2EEcvT__EES2_",
+     "decltype((test7::C)({1, 2}), (int)()) test7::fC2<int>(int)"},
+    {"_ZN5test73fD1IiEEDTcmtlNS_1DEL_ZNS_1bEEEcvT__EES2_",
+     "decltype(test7::D{test7::b}, (int)()) test7::fD1<int>(int)"},
+    {"_ZN5test73fE1IiEEDTcmtlNS_1EELi1ELi2EEcvT__EES2_", "decltype(test7::E{1, 2}, (int)()) test7::fE1<int>(int)"},
+    {"_ZN5test73fE2IiEEDTcmcvNS_1EEilLi1ELi2EEcvT__EES2_",
+     "decltype((test7::E)({1, 2}), (int)()) test7::fE2<int>(int)"},
+    {"_ZN5test73fF1IiEEDTcmtlNS_1FEilLi1ELi2EEEcvT__EES2_", "decltype(test7::F{{1, 2}}, (int)()) test7::fF1<int>(int)"},
+    {"_ZN5test73fF2IiEEDTcmcvNS_1FEilLi1ELi2EEcvT__EES2_",
+     "decltype((test7::F)({1, 2}), (int)()) test7::fF2<int>(int)"},
     {"_ZN5test73fT1IiEEDTtlT_EES1_", "decltype(int{}) test7::fT1<int>(int)"},
     {"_ZN5test73fT3IiEEDTtlT_Li1EEES1_", "decltype(int{1}) test7::fT3<int>(int)"},
     {"_ZN5test73fT5INS_1BEEEDTtlT_Li1ELi2EEES2_", "decltype(test7::B{1, 2}) test7::fT5<test7::B>(test7::B)"},
     {"_ZN5test73fT7INS_1AEEEDTtlT_ilEEES2_", "decltype(test7::A{{}}) test7::fT7<test7::A>(test7::A)"},
     {"_ZN5test73fT8INS_1AEEEDTcvT_ilEES2_", "decltype((test7::A)({})) test7::fT8<test7::A>(test7::A)"},
     {"_ZN5test73fT9INS_1AEEEDTtlT_ilLi1EEEES2_", "decltype(test7::A{{1}}) test7::fT9<test7::A>(test7::A)"},
     {"_ZN5test73fTAINS_1AEEEDTcvT_ilLi1EEES2_", "decltype((test7::A)({1})) test7::fTA<test7::A>(test7::A)"},
     {"_ZN5test73fTBINS_1CEEEDTtlT_ilLi1ELi2EEEES2_", "decltype(test7::C{{1, 2}}) test7::fTB<test7::C>(test7::C)"},
//    {"_Z1fM1XRFivEMS_OFivEMS_KOFivE", "f(int (X::*)() &, int (X::*)() &&, int (X::*)() const &&)"},
 
     {"_ZGRDC1x1yE_", "reference temporary for [x, y]"},
     {"_ZGR1bIvE2_", "reference temporary for b<void>"},
 
     {"_ZZ18test_assign_throwsI20small_throws_on_copyLb0EEvvENKUlRNSt3__13anyEOT_E_clIRS0_EEDaS3_S5_", "auto void test_assign_throws<small_throws_on_copy, false>()::'lambda'(std::__1::any&, auto&&)::operator()<small_throws_on_copy&>(std::__1::any&, auto&&) const"},
 
     // enable_if attributes:
     {"_Z1fUa9enable_ifIXLi1EEEv", "f() [enable_if:1]"},
-    {"_ZN5test4IdE1fEUa9enable_ifIXeqfL0p_Li1EEXeqfL0p0_Li2EEEi", "test4<double>::f(int) [enable_if:(fp) == (1), (fp0) == (2)]"},
+    {"_ZN5test4IdE1fEUa9enable_ifIXeqfL0p_Li1EEXeqfL0p0_Li2EEEi",
+     "test4<double>::f(int) [enable_if:fp == 1, fp0 == 2]"},
     {"_Z3quxUa9enable_ifIXLi1EEXL_Z9TRUEFACTSEEEi", "qux(int) [enable_if:1, TRUEFACTS]"},
 
     // Conversion operators:
     {"_ZN5OuterI4MarpEcv7MuncherIJT_T0_DpT1_EEI4MerpS0_JicfEEEv", "Outer<Marp>::operator Muncher<Merp, Marp, int, char, float><Merp, Marp, int, char, float>()"},
     {"_ZN5OuterI4MarpEcvT_I4MerpEEv", "Outer<Marp>::operator Merp<Merp>()"},
     {"_ZZN5OuterI4MarpEcv7MuncherIJT_T0_DpT1_EEI4MerpS0_JicfEEEvEN1ScvS9_Ev", "Outer<Marp>::operator Muncher<Merp, Marp, int, char, float><Merp, Marp, int, char, float>()::S::operator Merp()"},
     {"_ZN1Scv7MuncherIJDpPT_EEIJFivEA_iEEEv", "S::operator Muncher<int (*)(), int (*) []><int (), int []>()"},
 
     {"_Z2f8IiJ8identityIiES0_IfEEEvRAsPiDpT0_T_DpNS3_4typeEE_i", "void f8<int, identity<int>, identity<float> >(int (&) [sizeof... (int, identity<int>, identity<float>, int, identity<int>::type, identity<float>::type)])"},
 
     {"_ZNK13StaticMembersIfE1xMUlvE_clEv", "StaticMembers<float>::x::'lambda'()::operator()() const"},
     {"_ZNK10inline_varMUlvE_clEv", "inline_var::'lambda'()::operator()() const"},
     // C++1z fold expressions:
     {"_Z6foldl1IJLi1ELi2ELi3EEEv1AIXfLplLi1ET_EE", "void foldl1<1, 2, 3>(A<(1 + ... + (1, 2, 3))>)"},
     {"_Z6foldr1IJLi1ELi2ELi3EEEv1AIXfRplT_Li1EEE", "void foldr1<1, 2, 3>(A<((1, 2, 3) + ... + 1)>)"},
     {"_Z5foldlIJLi1ELi2ELi3EEEv1AIXflplT_EE", "void foldl<1, 2, 3>(A<(... + (1, 2, 3))>)"},
     {"_Z5foldrIJLi1ELi2ELi3EEEv1AIXfrplT_EE", "void foldr<1, 2, 3>(A<((1, 2, 3) + ...)>)"},
-    {"_ZN7PartialIJLi1ELi2EEE5foldrIJLi3ELi4EEEEv1AIXplLi1EplLi2EfRplT_plLi1EplLi2EfrplT_EE", "void Partial<1, 2>::foldr<3, 4>(A<(1) + ((2) + (((3, 4) + ... + (1) + ((2) + (((3, 4) + ...))))))>)"},
+    {"_ZN7PartialIJLi1ELi2EEE5foldrIJLi3ELi4EEEEv1AIXplLi1EplLi2EfRplT_plLi1EplLi2EfrplT_EE",
+     "void Partial<1, 2>::foldr<3, 4>(A<1 + (2 + ((3, 4) + ... + (1 + (2 + ((3, 4) + ...)))))>)"},
+    {"_ZN7PartialIJLi1ELi2EEE5foldrIJLi3ELi4EEEEv1AIXplplLi1ELi2EfRplT_plplLi1ELi2EflplT_EE",
+     "void Partial<1, 2>::foldr<3, 4>(A<1 + 2 + ((3, 4) + ... + (1 + 2 + (... + (3, 4))))>)"},
 
     // reference collapsing:
     {"_Z1fIR1SEiOT_", "int f<S&>(S&)"},
     {"_Z1fIJR1SS0_EEiDpOT_", "int f<S&, S>(S&, S&&)"},
 
     {"___Z3foo_block_invoke.25", "invocation function for block in foo"},
 
     // Darwin adds leading underscores to symbols, just demangle them anyways.
//    {"_Z1fM1XRFivEMS_OFivEMS_KOFivE", "f(int (X::*)() &, int (X::*)() &&, int (X::*)() const &&)"},
     // See https://github.com/itanium-cxx-abi/cxx-abi/issues/106.
     {"_ZN1XIZ1fIiEvOT_EUlS2_DpT0_E_EclIJEEEvDpT_", "void X<void f<int>(int&&)::'lambda'(int&&, auto...)>::operator()<>()"},
     {"_ZZZZN6abcdef9abcdefghi29abcdefabcdefabcdefabcefabcdef27xxxxxxxxxxxxxxxxxxxxxxxxxxxEN4absl8DurationERKNSt3__u12basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEPNS1_19yyyyyyyyyyyyyyyyyyyEENK3$_5clEvENKUlvE_clEvE6zzzzzz", "abcdef::abcdefghi::abcdefabcdefabcdefabcefabcdef::xxxxxxxxxxxxxxxxxxxxxxxxxxx(absl::Duration, std::__u::basic_string<char, std::__u::char_traits<char>, std::__u::allocator<char> > const&, abcdef::abcdefghi::abcdefabcdefabcdefabcefabcdef::yyyyyyyyyyyyyyyyyyy*)::$_5::operator()() const::'lambda'()::operator()() const::zzzzzz"},
 
     // C++2a class type non-type template parameters:
     {"_Z1fIXtl1BLPi0ELi1EEEEvv", "void f<B{(int*)0, 1}>()"},
     {"_Z1fIXtl1BLPi32EEEEvv", "void f<B{(int*)32}>()"},
     {"_Z1fIXtl1BrcPiLi0EEEEvv", "void f<B{reinterpret_cast<int*>(0)}>()"},
-    {"_Z1fIXtl1BadsoiL_Z6nestedE_EEEEvv", "void f<B{&(nested.<int at offset 0>)}>()"},
-    {"_Z1fIXtl1BadsoiL_Z6nestedE16_0pEEEEvv", "void f<B{&(nested.<int at offset 16>)}>()"},
+    {"_Z1fIXtl1BadsoiL_Z6nestedE_EEEEvv", "void f<B{&nested.<int at offset 0>}>()"},
+    {"_Z1fIXtl1BadsoiL_Z6nestedE16_0pEEEEvv", "void f<B{&nested.<int at offset 16>}>()"},
     {"_Z1fIXtl2BRsoiL_Z7derivedE4EEEEvv", "void f<BR{derived.<int at offset 4>}>()"},
-    {"_Z1fIXtl1BcvPiplcvPcadL_Z7derivedELl16EEEEvv", "void f<B{(int*)(((char*)(&(derived))) + (16l))}>()"},
-    {"_Z1fIXtl1CadsoKiL_Z7derivedE4EEEEvv", "void f<C{&(derived.<int const at offset 4>)}>()"},
+    {"_Z1fIXtl1BcvPiplcvPcadL_Z7derivedELl16EEEEvv", "void f<B{(int*)((char*)(&derived) + 16l)}>()"},
+    {"_Z1fIXtl1CadsoKiL_Z7derivedE4EEEEvv", "void f<C{&derived.<int const at offset 4>}>()"},
     {"_Z1fIXtl1DLM7DerivedKi0ELi1EEEEvv", "void f<D{(int const Derived::*)0, 1}>()"},
     // FIXME: This is not valid pointer-to-member syntax.
-    {"_Z1fIXtl1DmcM7DerivedKiadL_ZN11MoreDerived1zEEn8EEEEvv", "void f<D{(int const Derived::*)(&(MoreDerived::z))}>()"},
+    {"_Z1fIXtl1DmcM7DerivedKiadL_ZN11MoreDerived1zEEn8EEEEvv", "void f<D{(int const Derived::*)(&MoreDerived::z)}>()"},
     {"_Z1fIXtl1Edi1nLi42EEEEvv", "void f<E{.n = 42}>()"},
     {"_ZTAXtl1StlA32_cLc104ELc101ELc108ELc108ELc111ELc32ELc119ELc111ELc114ELc108ELc100EEEE", "template parameter object for S{char [32]{(char)104, (char)101, (char)108, (char)108, (char)111, (char)32, (char)119, (char)111, (char)114, (char)108, (char)100}}"},
 
     // FIXME: This is wrong; the S2_ backref should expand to OT_ and then to
     // "double&&". But we can't cope with a substitution that represents a
     // different type the node it is a substitute for.
     // See https://github.com/itanium-cxx-abi/cxx-abi/issues/106.
     {"_Z1h1XIJZ1fIiEDaOT_E1AZ1gIdEDaS2_E1BEE", "h(X<auto f<int>(int&&)::A, auto g<double>(int&&)::B>)"},
//    {"_Z1fM1XRFivEMS_OFivEMS_KOFivE", "f(int (X::*)() &, int (X::*)() &&, int (X::*)() const &&)"},
     {"_ZGIW3Foo", "initializer for module Foo"},
     {"_ZGIW3FooW3Bar", "initializer for module Foo.Bar"},
     {"_ZGIW3FooWP3BarW3Baz", "initializer for module Foo:Bar.Baz"},
 };
 
 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];
-} fp_literal_cases[] =
+  const char* mangled;
+} fp_literal_cases[] = {
+    {"_ZN5test01gIfEEvRAszplcvT__ELf40a00000E_c",
      {
-    {"_ZN5test01gIfEEvRAszplcvT__ELf40a00000E_c", {
-        "void test0::g<float>(char (&) [sizeof (((float)()) + (0x1.4p+2f))])",
-        "void test0::g<float>(char (&) [sizeof (((float)()) + (0x2.8p+1f))])",
-        "void test0::g<float>(char (&) [sizeof (((float)()) + (0x5p+0f))])",
-        "void test0::g<float>(char (&) [sizeof (((float)()) + (0xap-1f))])",
+         "void test0::g<float>(char (&) [sizeof ((float)() + 0x1.4p+2f)])",
+         "void test0::g<float>(char (&) [sizeof ((float)() + 0x2.8p+1f)])",
+         "void test0::g<float>(char (&) [sizeof ((float)() + 0x5p+0f)])",
+         "void test0::g<float>(char (&) [sizeof ((float)() + 0xap-1f)])",
      }},
-    {"_ZN5test01hIfEEvRAszplcvT__ELd4014000000000000E_c", {
-        "void test0::h<float>(char (&) [sizeof (((float)()) + (0x1.4p+2))])",
-        "void test0::h<float>(char (&) [sizeof (((float)()) + (0x2.8p+1))])",
-        "void test0::h<float>(char (&) [sizeof (((float)()) + (0x5p+0))])",
-        "void test0::h<float>(char (&) [sizeof (((float)()) + (0xap-1))])",
+    {"_ZN5test01hIfEEvRAszplcvT__ELd4014000000000000E_c",
+     {
+         "void test0::h<float>(char (&) [sizeof ((float)() + 0x1.4p+2)])",
+         "void test0::h<float>(char (&) [sizeof ((float)() + 0x2.8p+1)])",
+         "void test0::h<float>(char (&) [sizeof ((float)() + 0x5p+0)])",
+         "void test0::h<float>(char (&) [sizeof ((float)() + 0xap-1)])",
      }},
 #if LDBL_FP80
-    {"_ZN5test01hIfEEvRAcvjplstT_Le4001a000000000000000E_c", {
-        "void test0::h<float>(char (&) [(unsigned int)((sizeof (float)) + (0x1.4p+2L))])",
-        "void test0::h<float>(char (&) [(unsigned int)((sizeof (float)) + (0x2.8p+1L))])",
-        "void test0::h<float>(char (&) [(unsigned int)((sizeof (float)) + (0x5p+0L))])",
-        "void test0::h<float>(char (&) [(unsigned int)((sizeof (float)) + (0xap-1L))])",
+    {"_ZN5test01hIfEEvRAcvjplstT_Le4001a000000000000000E_c",
+     {
+         "void test0::h<float>(char (&) [(unsigned int)(sizeof (float) + 0x1.4p+2L)])",
+         "void test0::h<float>(char (&) [(unsigned int)(sizeof (float) + 0x2.8p+1L)])",
+         "void test0::h<float>(char (&) [(unsigned int)(sizeof (float) + 0x5p+0L)])",
+         "void test0::h<float>(char (&) [(unsigned int)(sizeof (float) + 0xap-1L)])",
      }},
 #endif
 #if LDBL_FP128
     // This was found by libFuzzer+HWASan on aarch64 Android.
     {"1\006ILeeeEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE",
      {"\x6<-0x1.cecececececececececececececep+11983L>"}},
 #endif
 };
 const unsigned NF = sizeof(fp_literal_cases) / sizeof(fp_literal_cases[0]);
void test()
     bool failed = false;
     for (unsigned i = 0; i < N; ++i)
     {
         int status;
         char* demang =
             __cxxabiv1::__cxa_demangle(cases[i][0], buf, &len, &status);
         if (!demang || std::strcmp(demang, cases[i][1]) != 0)
         {
-            std::printf("ERROR demangling %s\nexpected: %s\n",
-                        cases[i][0], cases[i][1]);
-            std::printf("Got: %d, %s\n", status, demang ? demang : "(null)");
-            failed = true;
+          std::fprintf(stderr, "ERROR demangling %s\n"
+                       "expected: %s\n"
+                       "got: %d,   %s\n",
+                       cases[i][0], cases[i][1], status,
+                       demang ? demang : "(null)");
         }
         if (demang)
           buf = demang;
     }
     free(buf);
     assert(!failed && "demangle failed");
 }
 

llvm/include/llvm/Demangle/ItaniumDemangle.h

#define ENUMERATOR(NodeKind) K ## NodeKind,
     FOR_EACH_NODE_KIND(ENUMERATOR)
 #undef ENUMERATOR
   };
 
   /// Three-way bool to track a cached value. Unknown is possible if this node
   /// has an unexpanded parameter pack below it that may affect this cache.
   enum class Cache : unsigned char { Yes, No, Unknown, };
 
+  /// Operator precedence for expression nodes. Used to determine required
+  /// parens in expression emission.
+  enum class Prec {
+    Primary,
+    Postfix,
+    Unary,
+    Cast,
+    PtrMem,
+    Multiplicative,
+    Additive,
+    Shift,
+    Spaceship,
+    Relational,
+    Equality,
+    And,
+    Xor,
+    Ior,
+    AndIf,
+    OrIf,
+    Conditional,
+    Assign,
+    Comma,
+    Default,
+  };
+
 private:
   Kind K;
 
+  Prec Precedence : 6;
+
   // FIXME: Make these protected.
 public:
   /// Tracks if this node has a component on its right side, in which case we
   /// need to call printRight.
-  Cache RHSComponentCache;
+  Cache RHSComponentCache : 2;
 
   /// Track if this node is a (possibly qualified) array type. This can affect
   /// how we format the output string.
-  Cache ArrayCache;
+  Cache ArrayCache : 2;
 
   /// Track if this node is a (possibly qualified) function type. This can
   /// affect how we format the output string.
-  Cache FunctionCache;
+  Cache FunctionCache : 2;
 
 public:
-  Node(Kind K_, Cache RHSComponentCache_ = Cache::No,
-       Cache ArrayCache_ = Cache::No, Cache FunctionCache_ = Cache::No)
-      : K(K_), RHSComponentCache(RHSComponentCache_), ArrayCache(ArrayCache_),
-        FunctionCache(FunctionCache_) {}
+  Node(Kind K_, Prec Precedence_ = Prec::Primary,
+       Cache RHSComponentCache_ = Cache::No, Cache ArrayCache_ = Cache::No,
+       Cache FunctionCache_ = Cache::No)
+      : K(K_), Precedence(Precedence_), RHSComponentCache(RHSComponentCache_),
+        ArrayCache(ArrayCache_), FunctionCache(FunctionCache_) {}
+  Node(Kind K_, Cache RHSComponentCache_, Cache ArrayCache_ = Cache::No,
+       Cache FunctionCache_ = Cache::No)
+      : Node(K_, Prec::Primary, RHSComponentCache_, ArrayCache_,
+             FunctionCache_) {}
 
   /// Visit the most-derived object corresponding to this object.
   template<typename Fn> void visit(Fn F) const;
 
   // The following function is provided by all derived classes:
   //
   // Call F with arguments that, when passed to the constructor of this node,
   // would construct an equivalent node.
public:
   bool hasFunction(OutputBuffer &OB) const {
     if (FunctionCache != Cache::Unknown)
       return FunctionCache == Cache::Yes;
     return hasFunctionSlow(OB);
   }
 
   Kind getKind() const { return K; }
 
+  Prec getPrecedence() const { return Precedence; }
+
   virtual bool hasRHSComponentSlow(OutputBuffer &) const { return false; }
   virtual bool hasArraySlow(OutputBuffer &) const { return false; }
   virtual bool hasFunctionSlow(OutputBuffer &) const { return false; }
 
   // Dig through "glue" nodes like ParameterPack and ForwardTemplateReference to
   // get at a node that actually represents some concrete syntax.
   virtual const Node *getSyntaxNode(OutputBuffer &) const { return this; }
 
+  // Print this node as an expression operand, surrounding it in parentheses if
+  // its precedence is [Strictly] weaker than P.
+  void printAsOperand(OutputBuffer &OB, Prec P = Prec::Default,
+                      bool StrictlyWorse = false) const {
+    bool Paren =
+        unsigned(getPrecedence()) >= unsigned(P) + unsigned(StrictlyWorse);
+    if (Paren)
+      OB.printOpen();
+    print(OB);
+    if (Paren)
+      OB.printClose();
+  }
+
   void print(OutputBuffer &OB) const {
     printLeft(OB);
     if (RHSComponentCache != Cache::No)
       printRight(OB);
   }
 
   // Print the "left" side of this Node into OutputBuffer.
   virtual void printLeft(OutputBuffer &) const = 0;
public:
 
   void printWithComma(OutputBuffer &OB) const {
     bool FirstElement = true;
     for (size_t Idx = 0; Idx != NumElements; ++Idx) {
       size_t BeforeComma = OB.getCurrentPosition();
       if (!FirstElement)
         OB += ", ";
       size_t AfterComma = OB.getCurrentPosition();
-      Elements[Idx]->print(OB);
+      Elements[Idx]->printAsOperand(OB, Node::Prec::Comma);
 
       // Elements[Idx] is an empty parameter pack expansion, we should erase the
       // comma we just printed.
       if (AfterComma == OB.getCurrentPosition()) {
         OB.setCurrentPosition(BeforeComma);
         continue;
       }
 
public:
   // by printing out the return types's left, then print our parameters, then
   // finally print right of the return type.
   void printLeft(OutputBuffer &OB) const override {
     Ret->printLeft(OB);
     OB += " ";
   }
 
   void printRight(OutputBuffer &OB) const override {
-    OB += "(";
+    OB.printOpen();
     Params.printWithComma(OB);
-    OB += ")";
+    OB.printClose();
     Ret->printRight(OB);
 
     if (CVQuals & QualConst)
       OB += " const";
     if (CVQuals & QualVolatile)
       OB += " volatile";
     if (CVQuals & QualRestrict)
       OB += " restrict";

 class NoexceptSpec : public Node {
   const Node *E;
 public:
   NoexceptSpec(const Node *E_) : Node(KNoexceptSpec), E(E_) {}
 
   template<typename Fn> void match(Fn F) const { F(E); }
 
   void printLeft(OutputBuffer &OB) const override {
-    OB += "noexcept(";
-    E->print(OB);
-    OB += ")";
+    OB += "noexcept";
+    OB.printOpen();
+    E->printAsOperand(OB);
+    OB.printClose();
   }
 };
 
 class DynamicExceptionSpec : public Node {
   NodeArray Types;
 public:
   DynamicExceptionSpec(NodeArray Types_)
       : Node(KDynamicExceptionSpec), Types(Types_) {}
 
   template<typename Fn> void match(Fn F) const { F(Types); }
 
   void printLeft(OutputBuffer &OB) const override {
-    OB += "throw(";
+    OB += "throw";
+    OB.printOpen();
     Types.printWithComma(OB);
-    OB += ')';
+    OB.printClose();
   }
 };
 
 class FunctionEncoding final : public Node {
   const Node *Ret;
   const Node *Name;
   NodeArray Params;
   const Node *Attrs;
if (Ret) {
       Ret->printLeft(OB);
       if (!Ret->hasRHSComponent(OB))
         OB += " ";
     }
     Name->print(OB);
   }
 
   void printRight(OutputBuffer &OB) const override {
-    OB += "(";
+    OB.printOpen();
     Params.printWithComma(OB);
-    OB += ")";
+    OB.printClose();
     if (Ret)
       Ret->printRight(OB);
 
     if (CVQuals & QualConst)
       OB += " const";
     if (CVQuals & QualVolatile)
       OB += " volatile";
     if (CVQuals & QualRestrict)

 public:
   TemplateTemplateParamDecl(Node *Name_, NodeArray Params_)
       : Node(KTemplateTemplateParamDecl, Cache::Yes), Name(Name_),
         Params(Params_) {}
 
   template<typename Fn> void match(Fn F) const { F(Name, Params); }
 
   void printLeft(OutputBuffer &OB) const override {
+    SwapAndRestore<unsigned> LT(OB.GtIsGt, 0);
     OB += "template<";
     Params.printWithComma(OB);
     OB += "> typename ";
   }
 
   void printRight(OutputBuffer &OB) const override { Name->print(OB); }
 };
 

 public:
   TemplateArgs(NodeArray Params_) : Node(KTemplateArgs), Params(Params_) {}
 
   template<typename Fn> void match(Fn F) const { F(Params); }
 
   NodeArray getParams() { return Params; }
 
   void printLeft(OutputBuffer &OB) const override {
+    SwapAndRestore<unsigned> LT(OB.GtIsGt, 0);
     OB += "<";
     Params.printWithComma(OB);
     if (OB.back() == '>')
       OB += " ";
     OB += ">";
   }
 };
 
ClosureTypeName(NodeArray TemplateParams_, NodeArray Params_,
         Params(Params_), Count(Count_) {}
 
   template<typename Fn> void match(Fn F) const {
     F(TemplateParams, Params, Count);
   }
 
   void printDeclarator(OutputBuffer &OB) const {
     if (!TemplateParams.empty()) {
+      SwapAndRestore<unsigned> LT(OB.GtIsGt, 0);
       OB += "<";
       TemplateParams.printWithComma(OB);
       OB += ">";
     }
-    OB += "(";
+    OB.printOpen();
     Params.printWithComma(OB);
-    OB += ")";
+    OB.printClose();
   }
 
   void printLeft(OutputBuffer &OB) const override {
     OB += "\'lambda";
     OB += Count;
     OB += "\'";
     printDeclarator(OB);
   }
 };
 
 class StructuredBindingName : public Node {
   NodeArray Bindings;
 public:
   StructuredBindingName(NodeArray Bindings_)
       : Node(KStructuredBindingName), Bindings(Bindings_) {}
 
   template<typename Fn> void match(Fn F) const { F(Bindings); }
 
   void printLeft(OutputBuffer &OB) const override {
-    OB += '[';
+    OB.printOpen('[');
     Bindings.printWithComma(OB);
-    OB += ']';
+    OB.printClose(']');
   }
 };
 
 // -- Expression Nodes --
 
 class BinaryExpr : public Node {
   const Node *LHS;
   const StringView InfixOperator;
   const Node *RHS;
 
 public:
-  BinaryExpr(const Node *LHS_, StringView InfixOperator_, const Node *RHS_)
-      : Node(KBinaryExpr), LHS(LHS_), InfixOperator(InfixOperator_), RHS(RHS_) {
-  }
+  BinaryExpr(const Node *LHS_, StringView InfixOperator_, const Node *RHS_,
+             Prec Prec_)
+      : Node(KBinaryExpr, Prec_), LHS(LHS_), InfixOperator(InfixOperator_),
+        RHS(RHS_) {}
 
   template<typename Fn> void match(Fn F) const { F(LHS, InfixOperator, RHS); }
 
   void printLeft(OutputBuffer &OB) const override {
-    // might be a template argument expression, then we need to disambiguate
-    // with parens.
-    if (InfixOperator == ">")
-      OB += "(";
-
-    OB += "(";
-    LHS->print(OB);
-    OB += ") ";
+    bool ParenAll = OB.isGtInsideTemplateArgs() && InfixOperator == ">";
+    if (ParenAll)
+      OB.printOpen();
+    // Assignment is right associative, with special LHS precedence.
+    bool IsAssign = getPrecedence() == Prec::Assign;
+    LHS->printAsOperand(OB, IsAssign ? Prec::OrIf : getPrecedence(), !IsAssign);
+    // No space before comma operator
+    if (!(InfixOperator == ","))
+      OB += " ";
     OB += InfixOperator;
-    OB += " (";
-    RHS->print(OB);
-    OB += ")";
-
-    if (InfixOperator == ">")
-      OB += ")";
+    OB += " ";
+    RHS->printAsOperand(OB, getPrecedence(), IsAssign);
+    if (ParenAll)
+      OB.printClose();
   }
 };
 
 class ArraySubscriptExpr : public Node {
   const Node *Op1;
   const Node *Op2;
 
 public:
-  ArraySubscriptExpr(const Node *Op1_, const Node *Op2_)
-      : Node(KArraySubscriptExpr), Op1(Op1_), Op2(Op2_) {}
+  ArraySubscriptExpr(const Node *Op1_, const Node *Op2_, Prec Prec_)
+      : Node(KArraySubscriptExpr, Prec_), Op1(Op1_), Op2(Op2_) {}
 
   template<typename Fn> void match(Fn F) const { F(Op1, Op2); }
 
   void printLeft(OutputBuffer &OB) const override {
-    OB += "(";
-    Op1->print(OB);
-    OB += ")[";
-    Op2->print(OB);
-    OB += "]";
+    Op1->printAsOperand(OB, getPrecedence());
+    OB.printOpen('[');
+    Op2->printAsOperand(OB);
+    OB.printClose(']');
   }
 };
 
 class PostfixExpr : public Node {
   const Node *Child;
   const StringView Operator;
 
 public:
-  PostfixExpr(const Node *Child_, StringView Operator_)
-      : Node(KPostfixExpr), Child(Child_), Operator(Operator_) {}
+  PostfixExpr(const Node *Child_, StringView Operator_, Prec Prec_)
+      : Node(KPostfixExpr, Prec_), Child(Child_), Operator(Operator_) {}
 
   template<typename Fn> void match(Fn F) const { F(Child, Operator); }
 
   void printLeft(OutputBuffer &OB) const override {
-    OB += "(";
-    Child->print(OB);
-    OB += ")";
+    Child->printAsOperand(OB, getPrecedence(), true);
     OB += Operator;
   }
 };
 
 class ConditionalExpr : public Node {
   const Node *Cond;
   const Node *Then;
   const Node *Else;
 
 public:
-  ConditionalExpr(const Node *Cond_, const Node *Then_, const Node *Else_)
-      : Node(KConditionalExpr), Cond(Cond_), Then(Then_), Else(Else_) {}
+  ConditionalExpr(const Node *Cond_, const Node *Then_, const Node *Else_,
+                  Prec Prec_)
+      : Node(KConditionalExpr, Prec_), Cond(Cond_), Then(Then_), Else(Else_) {}
 
   template<typename Fn> void match(Fn F) const { F(Cond, Then, Else); }
 
   void printLeft(OutputBuffer &OB) const override {
-    OB += "(";
-    Cond->print(OB);
-    OB += ") ? (";
-    Then->print(OB);
-    OB += ") : (";
-    Else->print(OB);
-    OB += ")";
+    Cond->printAsOperand(OB, getPrecedence());
+    OB += " ? ";
+    Then->printAsOperand(OB);
+    OB += " : ";
+    Else->printAsOperand(OB, Prec::Assign, true);
   }
 };
 
 class MemberExpr : public Node {
   const Node *LHS;
   const StringView Kind;
   const Node *RHS;
 
 public:
-  MemberExpr(const Node *LHS_, StringView Kind_, const Node *RHS_)
-      : Node(KMemberExpr), LHS(LHS_), Kind(Kind_), RHS(RHS_) {}
+  MemberExpr(const Node *LHS_, StringView Kind_, const Node *RHS_, Prec Prec_)
+      : Node(KMemberExpr, Prec_), LHS(LHS_), Kind(Kind_), RHS(RHS_) {}
 
   template<typename Fn> void match(Fn F) const { F(LHS, Kind, RHS); }
 
   void printLeft(OutputBuffer &OB) const override {
-    LHS->print(OB);
+    LHS->printAsOperand(OB, getPrecedence(), true);
     OB += Kind;
-    // Parenthesize pointer-to-member deference argument.
-    bool IsPtr = Kind.back() == '*';
-    if (IsPtr)
-      OB += '(';
-    RHS->print(OB);
-    if (IsPtr)
-      OB += ')';
+    RHS->printAsOperand(OB, getPrecedence(), false);
   }
 };
 
 class SubobjectExpr : public Node {
   const Node *Type;
   const Node *SubExpr;
   StringView Offset;
   NodeArray UnionSelectors;

 };
 
 class EnclosingExpr : public Node {
   const StringView Prefix;
   const Node *Infix;
   const StringView Postfix;
 
 public:
-  EnclosingExpr(StringView Prefix_, Node *Infix_, StringView Postfix_)
-      : Node(KEnclosingExpr), Prefix(Prefix_), Infix(Infix_),
-        Postfix(Postfix_) {}
+  EnclosingExpr(StringView Prefix_, Node *Infix_, Prec Prec_ = Prec::Primary)
+      : Node(KEnclosingExpr, Prec_), Prefix(Prefix_), Infix(Infix_) {}
 
-  template<typename Fn> void match(Fn F) const { F(Prefix, Infix, Postfix); }
+  template <typename Fn> void match(Fn F) const { F(Prefix, Infix); }
 
   void printLeft(OutputBuffer &OB) const override {
     OB += Prefix;
+    OB.printOpen();
     Infix->print(OB);
+    OB.printClose();
     OB += Postfix;
   }
 };
 
 class CastExpr : public Node {
   // cast_kind<to>(from)
   const StringView CastKind;
   const Node *To;
   const Node *From;
 
 public:
-  CastExpr(StringView CastKind_, const Node *To_, const Node *From_)
-      : Node(KCastExpr), CastKind(CastKind_), To(To_), From(From_) {}
+  CastExpr(StringView CastKind_, const Node *To_, const Node *From_, Prec Prec_)
+      : Node(KCastExpr, Prec_), CastKind(CastKind_), To(To_), From(From_) {}
 
   template<typename Fn> void match(Fn F) const { F(CastKind, To, From); }
 
   void printLeft(OutputBuffer &OB) const override {
     OB += CastKind;
+    {
+      SwapAndRestore<unsigned> LT(OB.GtIsGt, 0);
       OB += "<";
       To->printLeft(OB);
-    OB += ">(";
-    From->printLeft(OB);
-    OB += ")";
+      if (OB.back() == '>')
+        OB += " ";
+      OB += ">";
+    }
+    OB.printOpen();
+    From->printAsOperand(OB);
+    OB.printClose();
   }
 };
 
 class SizeofParamPackExpr : public Node {
   const Node *Pack;
 
 public:
   SizeofParamPackExpr(const Node *Pack_)
       : Node(KSizeofParamPackExpr), Pack(Pack_) {}
 
   template<typename Fn> void match(Fn F) const { F(Pack); }
 
   void printLeft(OutputBuffer &OB) const override {
-    OB += "sizeof...(";
+    OB += "sizeof...";
+    OB.printOpen();
     ParameterPackExpansion PPE(Pack);
     PPE.printLeft(OB);
-    OB += ")";
+    OB.printClose();
   }
 };
 
 class CallExpr : public Node {
   const Node *Callee;
   NodeArray Args;
 
 public:
-  CallExpr(const Node *Callee_, NodeArray Args_)
-      : Node(KCallExpr), Callee(Callee_), Args(Args_) {}
+  CallExpr(const Node *Callee_, NodeArray Args_, Prec Prec_)
+      : Node(KCallExpr, Prec_), Callee(Callee_), Args(Args_) {}
 
   template<typename Fn> void match(Fn F) const { F(Callee, Args); }
 
   void printLeft(OutputBuffer &OB) const override {
     Callee->print(OB);
-    OB += "(";
+    OB.printOpen();
     Args.printWithComma(OB);
-    OB += ")";
+    OB.printClose();
   }
 };
 
 class NewExpr : public Node {
   // new (expr_list) type(init_list)
   NodeArray ExprList;
   Node *Type;
   NodeArray InitList;
   bool IsGlobal; // ::operator new ?
   bool IsArray;  // new[] ?
 public:
   NewExpr(NodeArray ExprList_, Node *Type_, NodeArray InitList_, bool IsGlobal_,
-          bool IsArray_)
-      : Node(KNewExpr), ExprList(ExprList_), Type(Type_), InitList(InitList_),
-        IsGlobal(IsGlobal_), IsArray(IsArray_) {}
+          bool IsArray_, Prec Prec_)
+      : Node(KNewExpr, Prec_), ExprList(ExprList_), Type(Type_),
+        InitList(InitList_), IsGlobal(IsGlobal_), IsArray(IsArray_) {}
 
   template<typename Fn> void match(Fn F) const {
     F(ExprList, Type, InitList, IsGlobal, IsArray);
   }
 
   void printLeft(OutputBuffer &OB) const override {
     if (IsGlobal)
       OB += "::";
     OB += "new";
     if (IsArray)
       OB += "[]";
     if (!ExprList.empty()) {
-      OB += "(";
+      OB.printOpen();
       ExprList.printWithComma(OB);
-      OB += ")";
+      OB.printClose();
     }
-    OB += ' ';
+    OB += " ";
     Type->print(OB);
     if (!InitList.empty()) {
-      OB += "(";
+      OB.printOpen();
       InitList.printWithComma(OB);
-      OB += ")";
+      OB.printClose();
     }
   }
 };
 
 class DeleteExpr : public Node {
   Node *Op;
   bool IsGlobal;
   bool IsArray;
 
 public:
-  DeleteExpr(Node *Op_, bool IsGlobal_, bool IsArray_)
-      : Node(KDeleteExpr), Op(Op_), IsGlobal(IsGlobal_), IsArray(IsArray_) {}
+  DeleteExpr(Node *Op_, bool IsGlobal_, bool IsArray_, Prec Prec_)
+      : Node(KDeleteExpr, Prec_), Op(Op_), IsGlobal(IsGlobal_),
+        IsArray(IsArray_) {}
 
   template<typename Fn> void match(Fn F) const { F(Op, IsGlobal, IsArray); }
 
   void printLeft(OutputBuffer &OB) const override {
     if (IsGlobal)
       OB += "::";
     OB += "delete";
     if (IsArray)
       OB += "[]";
     OB += ' ';
     Op->print(OB);
   }
 };
 
 class PrefixExpr : public Node {
   StringView Prefix;
   Node *Child;
 
 public:
-  PrefixExpr(StringView Prefix_, Node *Child_)
-      : Node(KPrefixExpr), Prefix(Prefix_), Child(Child_) {}
+  PrefixExpr(StringView Prefix_, Node *Child_, Prec Prec_)
+      : Node(KPrefixExpr, Prec_), Prefix(Prefix_), Child(Child_) {}
 
   template<typename Fn> void match(Fn F) const { F(Prefix, Child); }
 
   void printLeft(OutputBuffer &OB) const override {
     OB += Prefix;
-    OB += "(";
-    Child->print(OB);
-    OB += ")";
+    Child->printAsOperand(OB, getPrecedence());
   }
 };
 
 class FunctionParam : public Node {
   StringView Number;
 
 public:
   FunctionParam(StringView Number_) : Node(KFunctionParam), Number(Number_) {}
 
   template<typename Fn> void match(Fn F) const { F(Number); }
 
   void printLeft(OutputBuffer &OB) const override {
     OB += "fp";
     OB += Number;
   }
 };
 
 class ConversionExpr : public Node {
   const Node *Type;
   NodeArray Expressions;
 
 public:
-  ConversionExpr(const Node *Type_, NodeArray Expressions_)
-      : Node(KConversionExpr), Type(Type_), Expressions(Expressions_) {}
+  ConversionExpr(const Node *Type_, NodeArray Expressions_, Prec Prec_)
+      : Node(KConversionExpr, Prec_), Type(Type_), Expressions(Expressions_) {}
 
   template<typename Fn> void match(Fn F) const { F(Type, Expressions); }
 
   void printLeft(OutputBuffer &OB) const override {
-    OB += "(";
+    OB.printOpen();
     Type->print(OB);
-    OB += ")(";
+    OB.printClose();
+    OB.printOpen();
     Expressions.printWithComma(OB);
-    OB += ")";
+    OB.printClose();
   }
 };
 
 class PointerToMemberConversionExpr : public Node {
   const Node *Type;
   const Node *SubExpr;
   StringView Offset;
 
 public:
   PointerToMemberConversionExpr(const Node *Type_, const Node *SubExpr_,
-                                StringView Offset_)
-      : Node(KPointerToMemberConversionExpr), Type(Type_), SubExpr(SubExpr_),
-        Offset(Offset_) {}
+                                StringView Offset_, Prec Prec_)
+      : Node(KPointerToMemberConversionExpr, Prec_), Type(Type_),
+        SubExpr(SubExpr_), Offset(Offset_) {}
 
   template<typename Fn> void match(Fn F) const { F(Type, SubExpr, Offset); }
 
   void printLeft(OutputBuffer &OB) const override {
-    OB += "(";
+    OB.printOpen();
     Type->print(OB);
-    OB += ")(";
+    OB.printClose();
+    OB.printOpen();
     SubExpr->print(OB);
-    OB += ")";
+    OB.printClose();
   }
 };
 
 class InitListExpr : public Node {
   const Node *Ty;
   NodeArray Inits;
 public:
   InitListExpr(const Node *Ty_, NodeArray Inits_)
FoldExpr(bool IsLeftFold_, StringView OperatorName_, const Node *Pack_,
         IsLeftFold(IsLeftFold_) {}
 
   template<typename Fn> void match(Fn F) const {
     F(IsLeftFold, OperatorName, Pack, Init);
   }
 
   void printLeft(OutputBuffer &OB) const override {
     auto PrintPack = [&] {
-      OB += '(';
+      OB.printOpen();
       ParameterPackExpansion(Pack).print(OB);
-      OB += ')';
+      OB.printClose();
     };
 
-    OB += '(';
-
-    if (IsLeftFold) {
-      // init op ... op pack
-      if (Init != nullptr) {
-        Init->print(OB);
-        OB += ' ';
-        OB += OperatorName;
-        OB += ' ';
-      }
-      // ... op pack
-      OB += "... ";
-      OB += OperatorName;
-      OB += ' ';
-      PrintPack();
-    } else { // !IsLeftFold
-      // pack op ...
+    OB.printOpen();
+    // Either '[init op ]... op pack' or 'pack op ...[ op init]'
+    // Refactored to '[(init|pack) op ]...[ op (pack|init)]'
+    // Fold expr operands are cast-expressions
+    if (!IsLeftFold || Init != nullptr) {
+      // '(init|pack) op '
+      if (IsLeftFold)
+        Init->printAsOperand(OB, Prec::Cast, true);
+      else
         PrintPack();
-      OB += ' ';
-      OB += OperatorName;
-      OB += " ...";
-      // pack op ... op init
-      if (Init != nullptr) {
-        OB += ' ';
-        OB += OperatorName;
-        OB += ' ';
-        Init->print(OB);
-      }
+      OB << " " << OperatorName << " ";
+    OB << "...";
+    if (IsLeftFold || Init != nullptr) {
+      // ' op (init|pack)'
+      OB << " " << OperatorName << " ";
+      if (IsLeftFold)
+        PrintPack();
+      else
+        Init->printAsOperand(OB, Prec::Cast, true);
     }
-    OB += ')';
+    OB.printClose();
   }
 };
 
 class ThrowExpr : public Node {
   const Node *Op;
 
 public:
   ThrowExpr(const Node *Op_) : Node(KThrowExpr), Op(Op_) {}

 
 public:
   EnumLiteral(const Node *Ty_, StringView Integer_)
       : Node(KEnumLiteral), Ty(Ty_), Integer(Integer_) {}
 
   template<typename Fn> void match(Fn F) const { F(Ty, Integer); }
 
   void printLeft(OutputBuffer &OB) const override {
-    OB << "(";
+    OB.printOpen();
     Ty->print(OB);
-    OB << ")";
+    OB.printClose();
 
     if (Integer[0] == 'n')
       OB << "-" << Integer.dropFront(1);
     else
       OB << Integer;
   }
 };
 
 class IntegerLiteral : public Node {
   StringView Type;
   StringView Value;
 
 public:
   IntegerLiteral(StringView Type_, StringView Value_)
       : Node(KIntegerLiteral), Type(Type_), Value(Value_) {}
 
   template<typename Fn> void match(Fn F) const { F(Type, Value); }
 
   void printLeft(OutputBuffer &OB) const override {
     if (Type.size() > 3) {
-      OB += "(";
+      OB.printOpen();
       OB += Type;
-      OB += ")";
+      OB.printClose();
     }
 
     if (Value[0] == 'n') {
-      OB += "-";
+      OB += '-';
       OB += Value.dropFront(1);
     } else
       OB += Value;
 
     if (Type.size() <= 3)
       OB += Type;
   }
 };
template <typename Derived, typename Alloc> struct AbstractManglingParser {
   Node *parseSubstitution();
   Node *parseTemplateParam();
   Node *parseTemplateParamDecl();
   Node *parseTemplateArgs(bool TagTemplates = false);
   Node *parseTemplateArg();
 
   /// Parse the <expr> production.
   Node *parseExpr();
-  Node *parsePrefixExpr(StringView Kind);
-  Node *parseBinaryExpr(StringView Kind);
+  Node *parsePrefixExpr(StringView Kind, Node::Prec Prec);
+  Node *parseBinaryExpr(StringView Kind, Node::Prec Prec);
   Node *parseIntegerLiteral(StringView Lit);
   Node *parseExprPrimary();
   template <class Float> Node *parseFloatingLiteral();
   Node *parseFunctionParam();
   Node *parseConversionExpr();
   Node *parseBracedExpr();
   Node *parseFoldExpr();
-  Node *parsePointerToMemberConversionExpr();
+  Node *parsePointerToMemberConversionExpr(Node::Prec Prec);
   Node *parseSubobjectExpr();
 
   /// Parse the <type> production.
   Node *parseType();
   Node *parseFunctionType();
   Node *parseVectorType();
   Node *parseDecltype();
   Node *parseArrayType();
enum OIKind : unsigned char {
       NamedCast, // Named cast, @<type>(expr)
       OfIdOp,    // alignof, sizeof, typeid
 
       Unnameable = NamedCast,
     };
     char Enc[2];      // Encoding
     OIKind Kind;      // Kind of operator
     bool Flag : 1;    // Entry-specific flag
+    Node::Prec Prec : 7; // Precedence
     const char *Name; // Spelling
 
   public:
-    constexpr OperatorInfo(const char (&E)[3], OIKind K, bool F, const char *N)
-        : Enc{E[0], E[1]}, Kind{K}, Flag{F}, Name{N} {}
+    constexpr OperatorInfo(const char (&E)[3], OIKind K, bool F, Node::Prec P,
+                           const char *N)
+        : Enc{E[0], E[1]}, Kind{K}, Flag{F}, Prec{P}, Name{N} {}
 
   public:
     bool operator<(const OperatorInfo &Other) const {
       return *this < Other.Enc;
     }
     bool operator<(const char *Peek) const {
       return Enc[0] < Peek[0] || (Enc[0] == Peek[0] && Enc[1] < Peek[1]);
     }
StringView getSymbol() const {
         Res = Res.dropFront(sizeof("operator") - 1);
         Res.consumeFront(' ');
       }
       return Res;
     }
     StringView getName() const { return Name; }
     OIKind getKind() const { return Kind; }
     bool getFlag() const { return Flag; }
+    Node::Prec getPrecedence() const { return Prec; }
   };
   const OperatorInfo *parseOperatorEncoding();
 
   /// Parse the <unresolved-name> production.
   Node *parseUnresolvedName(bool Global);
   Node *parseSimpleId();
   Node *parseBaseUnresolvedName();
   Node *parseUnresolvedType();

 
 // If the next 2 chars are an operator encoding, consume them and return their
 // OperatorInfo.  Otherwise return nullptr.
 template <typename Derived, typename Alloc>
 const typename AbstractManglingParser<Derived, Alloc>::OperatorInfo *
 AbstractManglingParser<Derived, Alloc>::parseOperatorEncoding() {
   static const OperatorInfo Ops[] = {
       // Keep ordered by encoding
-      {"aN", OperatorInfo::Binary, false, "operator&="},
-      {"aS", OperatorInfo::Binary, false, "operator="},
-      {"aa", OperatorInfo::Binary, false, "operator&&"},
-      {"ad", OperatorInfo::Prefix, false, "operator&"},
-      {"an", OperatorInfo::Binary, false, "operator&"},
-      {"at", OperatorInfo::OfIdOp, /*Type*/ true, "alignof ("},
-      {"aw", OperatorInfo::NameOnly, false, "operator co_await"},
-      {"az", OperatorInfo::OfIdOp, /*Type*/ false, "alignof ("},
-      {"cc", OperatorInfo::NamedCast, false, "const_cast"},
-      {"cl", OperatorInfo::Call, false, "operator()"},
-      {"cm", OperatorInfo::Binary, false, "operator,"},
-      {"co", OperatorInfo::Prefix, false, "operator~"},
-      {"cv", OperatorInfo::CCast, false, "operator"}, // C Cast
-      {"dV", OperatorInfo::Binary, false, "operator/="},
-      {"da", OperatorInfo::Del, /*Ary*/ true, "operator delete[]"},
-      {"dc", OperatorInfo::NamedCast, false, "dynamic_cast"},
-      {"de", OperatorInfo::Prefix, false, "operator*"},
-      {"dl", OperatorInfo::Del, /*Ary*/ false, "operator delete"},
-      {"ds", OperatorInfo::Member, /*Named*/ false, "operator.*"},
-      {"dt", OperatorInfo::Member, /*Named*/ false, "operator."},
-      {"dv", OperatorInfo::Binary, false, "operator/"},
-      {"eO", OperatorInfo::Binary, false, "operator^="},
-      {"eo", OperatorInfo::Binary, false, "operator^"},
-      {"eq", OperatorInfo::Binary, false, "operator=="},
-      {"ge", OperatorInfo::Binary, false, "operator>="},
-      {"gt", OperatorInfo::Binary, false, "operator>"},
-      {"ix", OperatorInfo::Array, false, "operator[]"},
-      {"lS", OperatorInfo::Binary, false, "operator<<="},
-      {"le", OperatorInfo::Binary, false, "operator<="},
-      {"ls", OperatorInfo::Binary, false, "operator<<"},
-      {"lt", OperatorInfo::Binary, false, "operator<"},
-      {"mI", OperatorInfo::Binary, false, "operator-="},
-      {"mL", OperatorInfo::Binary, false, "operator*="},
-      {"mi", OperatorInfo::Binary, false, "operator-"},
-      {"ml", OperatorInfo::Binary, false, "operator*"},
-      {"mm", OperatorInfo::Postfix, false, "operator--"},
-      {"na", OperatorInfo::New, /*Ary*/ true, "operator new[]"},
-      {"ne", OperatorInfo::Binary, false, "operator!="},
-      {"ng", OperatorInfo::Prefix, false, "operator-"},
-      {"nt", OperatorInfo::Prefix, false, "operator!"},
-      {"nw", OperatorInfo::New, /*Ary*/ false, "operator new"},
-      {"oR", OperatorInfo::Binary, false, "operator|="},
-      {"oo", OperatorInfo::Binary, false, "operator||"},
-      {"or", OperatorInfo::Binary, false, "operator|"},
-      {"pL", OperatorInfo::Binary, false, "operator+="},
-      {"pl", OperatorInfo::Binary, false, "operator+"},
-      {"pm", OperatorInfo::Member, /*Named*/ false, "operator->*"},
-      {"pp", OperatorInfo::Postfix, false, "operator++"},
-      {"ps", OperatorInfo::Prefix, false, "operator+"},
-      {"pt", OperatorInfo::Member, /*Named*/ true, "operator->"},
-      {"qu", OperatorInfo::Conditional, false, "operator?"},
-      {"rM", OperatorInfo::Binary, false, "operator%="},
-      {"rS", OperatorInfo::Binary, false, "operator>>="},
-      {"rc", OperatorInfo::NamedCast, false, "reinterpret_cast"},
-      {"rm", OperatorInfo::Binary, false, "operator%"},
-      {"rs", OperatorInfo::Binary, false, "operator>>"},
-      {"sc", OperatorInfo::NamedCast, false, "static_cast"},
-      {"ss", OperatorInfo::Binary, false, "operator<=>"},
-      {"st", OperatorInfo::OfIdOp, /*Type*/ true, "sizeof ("},
-      {"sz", OperatorInfo::OfIdOp, /*Type*/ false, "sizeof ("},
-      {"te", OperatorInfo::OfIdOp, /*Type*/ false, "typeid ("},
-      {"ti", OperatorInfo::OfIdOp, /*Type*/ true, "typeid ("},
+      {"aN", OperatorInfo::Binary, false, Node::Prec::Assign, "operator&="},
+      {"aS", OperatorInfo::Binary, false, Node::Prec::Assign, "operator="},
+      {"aa", OperatorInfo::Binary, false, Node::Prec::AndIf, "operator&&"},
+      {"ad", OperatorInfo::Prefix, false, Node::Prec::Unary, "operator&"},
+      {"an", OperatorInfo::Binary, false, Node::Prec::And, "operator&"},
+      {"at", OperatorInfo::OfIdOp, /*Type*/ true, Node::Prec::Unary,
+       "alignof "},
+      {"aw", OperatorInfo::NameOnly, false, Node::Prec::Primary,
+       "operator co_await"},
+      {"az", OperatorInfo::OfIdOp, /*Type*/ false, Node::Prec::Unary,
+       "alignof "},
+      {"cc", OperatorInfo::NamedCast, false, Node::Prec::Postfix, "const_cast"},
+      {"cl", OperatorInfo::Call, false, Node::Prec::Postfix, "operator()"},
+      {"cm", OperatorInfo::Binary, false, Node::Prec::Comma, "operator,"},
+      {"co", OperatorInfo::Prefix, false, Node::Prec::Unary, "operator~"},
+      {"cv", OperatorInfo::CCast, false, Node::Prec::Cast,
+       "operator"}, // C Cast
+      {"dV", OperatorInfo::Binary, false, Node::Prec::Assign, "operator/="},
+      {"da", OperatorInfo::Del, /*Ary*/ true, Node::Prec::Unary,
+       "operator delete[]"},
+      {"dc", OperatorInfo::NamedCast, false, Node::Prec::Postfix,
+       "dynamic_cast"},
+      {"de", OperatorInfo::Prefix, false, Node::Prec::Unary, "operator*"},
+      {"dl", OperatorInfo::Del, /*Ary*/ false, Node::Prec::Unary,
+       "operator delete"},
+      {"ds", OperatorInfo::Member, /*Named*/ false, Node::Prec::PtrMem,
+       "operator.*"},
+      {"dt", OperatorInfo::Member, /*Named*/ false, Node::Prec::Postfix,
+       "operator."},
+      {"dv", OperatorInfo::Binary, false, Node::Prec::Assign, "operator/"},
+      {"eO", OperatorInfo::Binary, false, Node::Prec::Assign, "operator^="},
+      {"eo", OperatorInfo::Binary, false, Node::Prec::Xor, "operator^"},
+      {"eq", OperatorInfo::Binary, false, Node::Prec::Equality, "operator=="},
+      {"ge", OperatorInfo::Binary, false, Node::Prec::Relational, "operator>="},
+      {"gt", OperatorInfo::Binary, false, Node::Prec::Relational, "operator>"},
+      {"ix", OperatorInfo::Array, false, Node::Prec::Postfix, "operator[]"},
+      {"lS", OperatorInfo::Binary, false, Node::Prec::Assign, "operator<<="},
+      {"le", OperatorInfo::Binary, false, Node::Prec::Relational, "operator<="},
+      {"ls", OperatorInfo::Binary, false, Node::Prec::Shift, "operator<<"},
+      {"lt", OperatorInfo::Binary, false, Node::Prec::Relational, "operator<"},
+      {"mI", OperatorInfo::Binary, false, Node::Prec::Assign, "operator-="},
+      {"mL", OperatorInfo::Binary, false, Node::Prec::Assign, "operator*="},
+      {"mi", OperatorInfo::Binary, false, Node::Prec::Additive, "operator-"},
+      {"ml", OperatorInfo::Binary, false, Node::Prec::Multiplicative,
+       "operator*"},
+      {"mm", OperatorInfo::Postfix, false, Node::Prec::Postfix, "operator--"},
+      {"na", OperatorInfo::New, /*Ary*/ true, Node::Prec::Unary,
+       "operator new[]"},
+      {"ne", OperatorInfo::Binary, false, Node::Prec::Equality, "operator!="},
+      {"ng", OperatorInfo::Prefix, false, Node::Prec::Unary, "operator-"},
+      {"nt", OperatorInfo::Prefix, false, Node::Prec::Unary, "operator!"},
+      {"nw", OperatorInfo::New, /*Ary*/ false, Node::Prec::Unary,
+       "operator new"},
+      {"oR", OperatorInfo::Binary, false, Node::Prec::Assign, "operator|="},
+      {"oo", OperatorInfo::Binary, false, Node::Prec::OrIf, "operator||"},
+      {"or", OperatorInfo::Binary, false, Node::Prec::Ior, "operator|"},
+      {"pL", OperatorInfo::Binary, false, Node::Prec::Assign, "operator+="},
+      {"pl", OperatorInfo::Binary, false, Node::Prec::Additive, "operator+"},
+      {"pm", OperatorInfo::Member, /*Named*/ false, Node::Prec::PtrMem,
+       "operator->*"},
+      {"pp", OperatorInfo::Postfix, false, Node::Prec::Postfix, "operator++"},
+      {"ps", OperatorInfo::Prefix, false, Node::Prec::Unary, "operator+"},
+      {"pt", OperatorInfo::Member, /*Named*/ true, Node::Prec::Postfix,
+       "operator->"},
+      {"qu", OperatorInfo::Conditional, false, Node::Prec::Conditional,
+       "operator?"},
+      {"rM", OperatorInfo::Binary, false, Node::Prec::Assign, "operator%="},
+      {"rS", OperatorInfo::Binary, false, Node::Prec::Assign, "operator>>="},
+      {"rc", OperatorInfo::NamedCast, false, Node::Prec::Postfix,
+       "reinterpret_cast"},
+      {"rm", OperatorInfo::Binary, false, Node::Prec::Multiplicative,
+       "operator%"},
+      {"rs", OperatorInfo::Binary, false, Node::Prec::Shift, "operator>>"},
+      {"sc", OperatorInfo::NamedCast, false, Node::Prec::Postfix,
+       "static_cast"},
+      {"ss", OperatorInfo::Binary, false, Node::Prec::Spaceship, "operator<=>"},
+      {"st", OperatorInfo::OfIdOp, /*Type*/ true, Node::Prec::Unary, "sizeof "},
+      {"sz", OperatorInfo::OfIdOp, /*Type*/ false, Node::Prec::Unary,
+       "sizeof "},
+      {"te", OperatorInfo::OfIdOp, /*Type*/ false, Node::Prec::Postfix,
+       "typeid "},
+      {"ti", OperatorInfo::OfIdOp, /*Type*/ true, Node::Prec::Postfix,
+       "typeid "},
   };
   const auto NumOps = sizeof(Ops) / sizeof(Ops[0]);
 
 #ifndef NDEBUG
   {
     // Verify table order.
     static bool Done;
     if (!Done) {
if (!consumeIf('D'))
     return nullptr;
   if (!consumeIf('t') && !consumeIf('T'))
     return nullptr;
   Node *E = getDerived().parseExpr();
   if (E == nullptr)
     return nullptr;
   if (!consumeIf('E'))
     return nullptr;
-  return make<EnclosingExpr>("decltype(", E, ")");
+  return make<EnclosingExpr>("decltype", E);
 }
 
 // <array-type> ::= A <positive dimension number> _ <element type>
 //              ::= A [<dimension expression>] _ <element type>
 template <typename Derived, typename Alloc>
 Node *AbstractManglingParser<Derived, Alloc>::parseArrayType() {
   if (!consumeIf('A'))
     return nullptr;
Node *AbstractManglingParser<Derived, Alloc>::parseType() {
   // <builtin-type>s and <substitution>s have already bailed out, because they
   // don't get substitutions.
   if (Result != nullptr)
     Subs.push_back(Result);
   return Result;
 }
 
 template <typename Derived, typename Alloc>
-Node *AbstractManglingParser<Derived, Alloc>::parsePrefixExpr(StringView Kind) {
+Node *AbstractManglingParser<Derived, Alloc>::parsePrefixExpr(StringView Kind,
+                                                              Node::Prec Prec) {
   Node *E = getDerived().parseExpr();
   if (E == nullptr)
     return nullptr;
-  return make<PrefixExpr>(Kind, E);
+  return make<PrefixExpr>(Kind, E, Prec);
 }
 
 template <typename Derived, typename Alloc>
-Node *AbstractManglingParser<Derived, Alloc>::parseBinaryExpr(StringView Kind) {
+Node *AbstractManglingParser<Derived, Alloc>::parseBinaryExpr(StringView Kind,
+                                                              Node::Prec Prec) {
   Node *LHS = getDerived().parseExpr();
   if (LHS == nullptr)
     return nullptr;
   Node *RHS = getDerived().parseExpr();
   if (RHS == nullptr)
     return nullptr;
-  return make<BinaryExpr>(LHS, Kind, RHS);
+  return make<BinaryExpr>(LHS, Kind, RHS, Prec);
 }
 
 template <typename Derived, typename Alloc>
 Node *
 AbstractManglingParser<Derived, Alloc>::parseIntegerLiteral(StringView Lit) {
   StringView Tmp = parseNumber(true);
   if (!Tmp.empty() && consumeIf('E'))
     return make<IntegerLiteral>(Lit, Tmp);
Node *AbstractManglingParser<Derived, Alloc>::parseFoldExpr() {
 
   return make<FoldExpr>(IsLeftFold, Op->getSymbol(), Pack, Init);
 }
 
 // <expression> ::= mc <parameter type> <expr> [<offset number>] E
 //
 // Not yet in the spec: https://github.com/itanium-cxx-abi/cxx-abi/issues/47
 template <typename Derived, typename Alloc>
-Node *AbstractManglingParser<Derived, Alloc>::parsePointerToMemberConversionExpr() {
+Node *
+AbstractManglingParser<Derived, Alloc>::parsePointerToMemberConversionExpr(
+    Node::Prec Prec) {
   Node *Ty = getDerived().parseType();
   if (!Ty)
     return nullptr;
   Node *Expr = getDerived().parseExpr();
   if (!Expr)
     return nullptr;
   StringView Offset = getDerived().parseNumber(true);
   if (!consumeIf('E'))
     return nullptr;
-  return make<PointerToMemberConversionExpr>(Ty, Expr, Offset);
+  return make<PointerToMemberConversionExpr>(Ty, Expr, Offset, Prec);
 }
 
 // <expression> ::= so <referent type> <expr> [<offset number>] <union-selector>* [p] E
 // <union-selector> ::= _ [<number>]
 //
 // Not yet in the spec: https://github.com/itanium-cxx-abi/cxx-abi/issues/47
 template <typename Derived, typename Alloc>
 Node *AbstractManglingParser<Derived, Alloc>::parseSubobjectExpr() {
Node *AbstractManglingParser<Derived, Alloc>::parseExpr() {
   bool Global = consumeIf("gs");
 
   const auto *Op = parseOperatorEncoding();
   if (Op) {
     auto Sym = Op->getSymbol();
     switch (Op->getKind()) {
     case OperatorInfo::Binary:
       // Binary operator: lhs @ rhs
-      return getDerived().parseBinaryExpr(Sym);
+      return getDerived().parseBinaryExpr(Sym, Op->getPrecedence());
     case OperatorInfo::Prefix:
       // Prefix unary operator: @ expr
-      return getDerived().parsePrefixExpr(Sym);
+      return getDerived().parsePrefixExpr(Sym, Op->getPrecedence());
     case OperatorInfo::Postfix: {
       // Postfix unary operator: expr @
       if (consumeIf('_'))
-        return getDerived().parsePrefixExpr(Sym);
+        return getDerived().parsePrefixExpr(Sym, Op->getPrecedence());
       Node *Ex = getDerived().parseExpr();
       if (Ex == nullptr)
         return nullptr;
-      return make<PostfixExpr>(Ex, Sym);
+      return make<PostfixExpr>(Ex, Sym, Op->getPrecedence());
     }
     case OperatorInfo::Array: {
       // Array Index:  lhs [ rhs ]
       Node *Base = getDerived().parseExpr();
       if (Base == nullptr)
         return nullptr;
       Node *Index = getDerived().parseExpr();
       if (Index == nullptr)
         return nullptr;
-      return make<ArraySubscriptExpr>(Base, Index);
+      return make<ArraySubscriptExpr>(Base, Index, Op->getPrecedence());
     }
     case OperatorInfo::Member: {
       // Member access lhs @ rhs
       Node *LHS = getDerived().parseExpr();
       if (LHS == nullptr)
         return nullptr;
       Node *RHS = getDerived().parseExpr();
       if (RHS == nullptr)
         return nullptr;
-      return make<MemberExpr>(LHS, Sym, RHS);
+      return make<MemberExpr>(LHS, Sym, RHS, Op->getPrecedence());
     }
     case OperatorInfo::New: {
       // New
       // # new (expr-list) type [(init)]
       // [gs] nw <expression>* _ <type> [pi <expression>*] E
       // # new[] (expr-list) type [(init)]
       // [gs] na <expression>* _ <type> [pi <expression>*] E
       size_t Exprs = Names.size();
case OperatorInfo::New: {
           return nullptr;
         Node *Init = getDerived().parseExpr();
         if (Init == nullptr)
           return Init;
         Names.push_back(Init);
       }
       NodeArray Inits = popTrailingNodeArray(InitsBegin);
       return make<NewExpr>(ExprList, Ty, Inits, Global,
-                           /*IsArray=*/Op->getFlag());
+                           /*IsArray=*/Op->getFlag(), Op->getPrecedence());
     }
     case OperatorInfo::Del: {
       // Delete
       Node *Ex = getDerived().parseExpr();
       if (Ex == nullptr)
         return nullptr;
-      return make<DeleteExpr>(Ex, Global, /*IsArray=*/Op->getFlag());
+      return make<DeleteExpr>(Ex, Global, /*IsArray=*/Op->getFlag(),
+                              Op->getPrecedence());
     }
     case OperatorInfo::Call: {
       // Function Call
       Node *Callee = getDerived().parseExpr();
       if (Callee == nullptr)
         return nullptr;
       size_t ExprsBegin = Names.size();
       while (!consumeIf('E')) {
         Node *E = getDerived().parseExpr();
         if (E == nullptr)
           return nullptr;
         Names.push_back(E);
       }
-      return make<CallExpr>(Callee, popTrailingNodeArray(ExprsBegin));
+      return make<CallExpr>(Callee, popTrailingNodeArray(ExprsBegin),
+                            Op->getPrecedence());
     }
     case OperatorInfo::CCast: {
       // C Cast: (type)expr
       Node *Ty;
       {
         SwapAndRestore<bool> SaveTemp(TryToParseTemplateArgs, false);
         Ty = getDerived().parseType();
       }
       if (Ty == nullptr)
         return nullptr;
 
       size_t ExprsBegin = Names.size();
       bool IsMany = consumeIf('_');
       while (!consumeIf('E')) {
         Node *E = getDerived().parseExpr();
         if (E == nullptr)
           return E;
         Names.push_back(E);
         if (!IsMany)
           break;
       }
       NodeArray Exprs = popTrailingNodeArray(ExprsBegin);
       if (!IsMany && Exprs.size() != 1)
         return nullptr;
-      return make<ConversionExpr>(Ty, Exprs);
+      return make<ConversionExpr>(Ty, Exprs, Op->getPrecedence());
     }
     case OperatorInfo::Conditional: {
       // Conditional operator: expr ? expr : expr
       Node *Cond = getDerived().parseExpr();
       if (Cond == nullptr)
         return nullptr;
       Node *LHS = getDerived().parseExpr();
       if (LHS == nullptr)
         return nullptr;
       Node *RHS = getDerived().parseExpr();
       if (RHS == nullptr)
         return nullptr;
-      return make<ConditionalExpr>(Cond, LHS, RHS);
+      return make<ConditionalExpr>(Cond, LHS, RHS, Op->getPrecedence());
     }
     case OperatorInfo::NamedCast: {
       // Named cast operation, @<type>(expr)
       Node *Ty = getDerived().parseType();
       if (Ty == nullptr)
         return nullptr;
       Node *Ex = getDerived().parseExpr();
       if (Ex == nullptr)
         return nullptr;
-      return make<CastExpr>(Sym, Ty, Ex);
+      return make<CastExpr>(Sym, Ty, Ex, Op->getPrecedence());
     }
     case OperatorInfo::OfIdOp: {
       // [sizeof/alignof/typeid] ( <type>|<expr> )
       Node *Arg =
           Op->getFlag() ? getDerived().parseType() : getDerived().parseExpr();
       if (!Arg)
         return nullptr;
-      return make<EnclosingExpr>(Sym, Arg, ")");
+      return make<EnclosingExpr>(Sym, Arg, Op->getPrecedence());
     }
     case OperatorInfo::NameOnly: {
       // Not valid as an expression operand.
       return nullptr;
     }
     }
     DEMANGLE_UNREACHABLE;
   }
while (!consumeIf('E')) {
       Node *E = getDerived().parseBracedExpr();
       if (E == nullptr)
         return nullptr;
       Names.push_back(E);
     }
     return make<InitListExpr>(nullptr, popTrailingNodeArray(InitsBegin));
   }
   if (consumeIf("mc"))
-    return parsePointerToMemberConversionExpr();
+    return parsePointerToMemberConversionExpr(Node::Prec::Unary);
   if (consumeIf("nx")) {
     Node *Ex = getDerived().parseExpr();
     if (Ex == nullptr)
       return Ex;
-    return make<EnclosingExpr>("noexcept (", Ex, ")");
+    return make<EnclosingExpr>("noexcept ", Ex, Node::Prec::Unary);
   }
   if (consumeIf("so"))
     return parseSubobjectExpr();
   if (consumeIf("sp")) {
     Node *Child = getDerived().parseExpr();
     if (Child == nullptr)
       return nullptr;
     return make<ParameterPackExpansion>(Child);
   }
   if (consumeIf("sZ")) {
     if (look() == 'T') {
       Node *R = getDerived().parseTemplateParam();
       if (R == nullptr)
         return nullptr;
       return make<SizeofParamPackExpr>(R);
     }
     Node *FP = getDerived().parseFunctionParam();
     if (FP == nullptr)
       return nullptr;
-    return make<EnclosingExpr>("sizeof... (", FP, ")");
+    return make<EnclosingExpr>("sizeof... ", FP);
   }
   if (consumeIf("sP")) {
     size_t ArgsBegin = Names.size();
     while (!consumeIf('E')) {
       Node *Arg = getDerived().parseTemplateArg();
       if (Arg == nullptr)
         return nullptr;
       Names.push_back(Arg);
     }
     auto *Pack = make<NodeArrayNode>(popTrailingNodeArray(ArgsBegin));
     if (!Pack)
       return nullptr;
-    return make<EnclosingExpr>("sizeof... (", Pack, ")");
+    return make<EnclosingExpr>("sizeof... ", Pack);
   }
   if (consumeIf("tl")) {
     Node *Ty = getDerived().parseType();
     if (Ty == nullptr)
       return nullptr;
     size_t InitsBegin = Names.size();
     while (!consumeIf('E')) {
       Node *E = getDerived().parseBracedExpr();
if (consumeIf('u')) {
     } else {
       while (!consumeIf('E')) {
         Node *E = getDerived().parseTemplateArg();
         if (E == nullptr)
           return E;
         Names.push_back(E);
       }
     }
-    return make<CallExpr>(Name, popTrailingNodeArray(ExprsBegin));
+    return make<CallExpr>(Name, popTrailingNodeArray(ExprsBegin),
+                          Node::Prec::Postfix);
   }
 
   // Only unresolved names remain.
   return getDerived().parseUnresolvedName(Global);
 }
 
 // <call-offset> ::= h <nv-offset> _
 //               ::= v <v-offset> _

llvm/include/llvm/Demangle/Utility.h

void reset(char *Buffer_, size_t BufferCapacity_) {
     BufferCapacity = BufferCapacity_;
   }
 
   /// If a ParameterPackExpansion (or similar type) is encountered, the offset
   /// into the pack that we're currently printing.
   unsigned CurrentPackIndex = std::numeric_limits<unsigned>::max();
   unsigned CurrentPackMax = std::numeric_limits<unsigned>::max();
 
+  /// When zero, we're printing template args and '>' needs to be parenthesized.
+  /// Use a counter so we can simply increment inside parentheses.
+  unsigned GtIsGt = 1;
+
+  bool isGtInsideTemplateArgs() const { return GtIsGt == 0; }
+
+  void printOpen(char Open = '(') {
+    GtIsGt++;
+    *this += Open;
+  }
+  void printClose(char Close = ')') {
+    GtIsGt--;
+    *this += Close;
+  }
+
   OutputBuffer &operator+=(StringView R) {
     if (size_t Size = R.size()) {
       grow(Size);
       std::memcpy(Buffer + CurrentPosition, R.begin(), Size);
       CurrentPosition += Size;
     }
     return *this;
   }