llvm/Demangle/MicrosoftDemangleNodes.h

0001 //===- MicrosoftDemangleNodes.h ---------------------------------*- C++ -*-===//
0002 //
0003 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
0004 // See https://llvm.org/LICENSE.txt for license information.
0005 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
0006 //
0007 //===----------------------------------------------------------------------===//
0008 //
0009 // This file defines the AST nodes used in the MSVC demangler.
0010 //
0011 //===----------------------------------------------------------------------===//
0012
0013 #ifndef LLVM_DEMANGLE_MICROSOFTDEMANGLENODES_H
0014 #define LLVM_DEMANGLE_MICROSOFTDEMANGLENODES_H
0015
0016 #include <array>
0017 #include <cstdint>
0018 #include <string>
0019 #include <string_view>
0020
0021 namespace llvm {
0022 namespace itanium_demangle {
0023 class OutputBuffer;
0024 }
0025 }
0026
0027 using llvm::itanium_demangle::OutputBuffer;
0028
0029 namespace llvm {
0030 namespace ms_demangle {
0031
0032 // Storage classes
0033 enum Qualifiers : uint8_t {
0034   Q_None = 0,
0035   Q_Const = 1 << 0,
0036   Q_Volatile = 1 << 1,
0037   Q_Far = 1 << 2,
0038   Q_Huge = 1 << 3,
0039   Q_Unaligned = 1 << 4,
0040   Q_Restrict = 1 << 5,
0041   Q_Pointer64 = 1 << 6
0042 };
0043
0044 enum class StorageClass : uint8_t {
0045   None,
0046   PrivateStatic,
0047   ProtectedStatic,
0048   PublicStatic,
0049   Global,
0050   FunctionLocalStatic,
0051 };
0052
0053 enum class PointerAffinity { None, Pointer, Reference, RValueReference };
0054 enum class FunctionRefQualifier { None, Reference, RValueReference };
0055
0056 // Calling conventions
0057 enum class CallingConv : uint8_t {
0058   None,
0059   Cdecl,
0060   Pascal,
0061   Thiscall,
0062   Stdcall,
0063   Fastcall,
0064   Clrcall,
0065   Eabi,
0066   Vectorcall,
0067   Regcall,
0068   Swift,      // Clang-only
0069   SwiftAsync, // Clang-only
0070 };
0071
0072 enum class ReferenceKind : uint8_t { None, LValueRef, RValueRef };
0073
0074 enum OutputFlags {
0075   OF_Default = 0,
0076   OF_NoCallingConvention = 1,
0077   OF_NoTagSpecifier = 2,
0078   OF_NoAccessSpecifier = 4,
0079   OF_NoMemberType = 8,
0080   OF_NoReturnType = 16,
0081   OF_NoVariableType = 32,
0082 };
0083
0084 // Types
0085 enum class PrimitiveKind {
0086   Void,
0087   Bool,
0088   Char,
0089   Schar,
0090   Uchar,
0091   Char8,
0092   Char16,
0093   Char32,
0094   Short,
0095   Ushort,
0096   Int,
0097   Uint,
0098   Long,
0099   Ulong,
0100   Int64,
0101   Uint64,
0102   Wchar,
0103   Float,
0104   Double,
0105   Ldouble,
0106   Nullptr,
0107   Auto,
0108   DecltypeAuto,
0109 };
0110
0111 enum class CharKind {
0112   Char,
0113   Char16,
0114   Char32,
0115   Wchar,
0116 };
0117
0118 enum class IntrinsicFunctionKind : uint8_t {
0119   None,
0120   New,                        // ?2 # operator new
0121   Delete,                     // ?3 # operator delete
0122   Assign,                     // ?4 # operator=
0123   RightShift,                 // ?5 # operator>>
0124   LeftShift,                  // ?6 # operator<<
0125   LogicalNot,                 // ?7 # operator!
0126   Equals,                     // ?8 # operator==
0127   NotEquals,                  // ?9 # operator!=
0128   ArraySubscript,             // ?A # operator[]
0129   Pointer,                    // ?C # operator->
0130   Dereference,                // ?D # operator*
0131   Increment,                  // ?E # operator++
0132   Decrement,                  // ?F # operator--
0133   Minus,                      // ?G # operator-
0134   Plus,                       // ?H # operator+
0135   BitwiseAnd,                 // ?I # operator&
0136   MemberPointer,              // ?J # operator->*
0137   Divide,                     // ?K # operator/
0138   Modulus,                    // ?L # operator%
0139   LessThan,                   // ?M operator<
0140   LessThanEqual,              // ?N operator<=
0141   GreaterThan,                // ?O operator>
0142   GreaterThanEqual,           // ?P operator>=
0143   Comma,                      // ?Q operator,
0144   Parens,                     // ?R operator()
0145   BitwiseNot,                 // ?S operator~
0146   BitwiseXor,                 // ?T operator^
0147   BitwiseOr,                  // ?U operator|
0148   LogicalAnd,                 // ?V operator&&
0149   LogicalOr,                  // ?W operator||
0150   TimesEqual,                 // ?X operator*=
0151   PlusEqual,                  // ?Y operator+=
0152   MinusEqual,                 // ?Z operator-=
0153   DivEqual,                   // ?_0 operator/=
0154   ModEqual,                   // ?_1 operator%=
0155   RshEqual,                   // ?_2 operator>>=
0156   LshEqual,                   // ?_3 operator<<=
0157   BitwiseAndEqual,            // ?_4 operator&=
0158   BitwiseOrEqual,             // ?_5 operator|=
0159   BitwiseXorEqual,            // ?_6 operator^=
0160   VbaseDtor,                  // ?_D # vbase destructor
0161   VecDelDtor,                 // ?_E # vector deleting destructor
0162   DefaultCtorClosure,         // ?_F # default constructor closure
0163   ScalarDelDtor,              // ?_G # scalar deleting destructor
0164   VecCtorIter,                // ?_H # vector constructor iterator
0165   VecDtorIter,                // ?_I # vector destructor iterator
0166   VecVbaseCtorIter,           // ?_J # vector vbase constructor iterator
0167   VdispMap,                   // ?_K # virtual displacement map
0168   EHVecCtorIter,              // ?_L # eh vector constructor iterator
0169   EHVecDtorIter,              // ?_M # eh vector destructor iterator
0170   EHVecVbaseCtorIter,         // ?_N # eh vector vbase constructor iterator
0171   CopyCtorClosure,            // ?_O # copy constructor closure
0172   LocalVftableCtorClosure,    // ?_T # local vftable constructor closure
0173   ArrayNew,                   // ?_U operator new[]
0174   ArrayDelete,                // ?_V operator delete[]
0175   ManVectorCtorIter,          // ?__A managed vector ctor iterator
0176   ManVectorDtorIter,          // ?__B managed vector dtor iterator
0177   EHVectorCopyCtorIter,       // ?__C EH vector copy ctor iterator
0178   EHVectorVbaseCopyCtorIter,  // ?__D EH vector vbase copy ctor iterator
0179   VectorCopyCtorIter,         // ?__G vector copy constructor iterator
0180   VectorVbaseCopyCtorIter,    // ?__H vector vbase copy constructor iterator
0181   ManVectorVbaseCopyCtorIter, // ?__I managed vector vbase copy constructor
0182   CoAwait,                    // ?__L operator co_await
0183   Spaceship,                  // ?__M operator<=>
0184   MaxIntrinsic
0185 };
0186
0187 enum class SpecialIntrinsicKind {
0188   None,
0189   Vftable,
0190   Vbtable,
0191   Typeof,
0192   VcallThunk,
0193   LocalStaticGuard,
0194   StringLiteralSymbol,
0195   UdtReturning,
0196   Unknown,
0197   DynamicInitializer,
0198   DynamicAtexitDestructor,
0199   RttiTypeDescriptor,
0200   RttiBaseClassDescriptor,
0201   RttiBaseClassArray,
0202   RttiClassHierarchyDescriptor,
0203   RttiCompleteObjLocator,
0204   LocalVftable,
0205   LocalStaticThreadGuard,
0206 };
0207
0208 // Function classes
0209 enum FuncClass : uint16_t {
0210   FC_None = 0,
0211   FC_Public = 1 << 0,
0212   FC_Protected = 1 << 1,
0213   FC_Private = 1 << 2,
0214   FC_Global = 1 << 3,
0215   FC_Static = 1 << 4,
0216   FC_Virtual = 1 << 5,
0217   FC_Far = 1 << 6,
0218   FC_ExternC = 1 << 7,
0219   FC_NoParameterList = 1 << 8,
0220   FC_VirtualThisAdjust = 1 << 9,
0221   FC_VirtualThisAdjustEx = 1 << 10,
0222   FC_StaticThisAdjust = 1 << 11,
0223 };
0224
0225 enum class TagKind { Class, Struct, Union, Enum };
0226
0227 enum class NodeKind {
0228   Unknown,
0229   Md5Symbol,
0230   PrimitiveType,
0231   FunctionSignature,
0232   Identifier,
0233   NamedIdentifier,
0234   VcallThunkIdentifier,
0235   LocalStaticGuardIdentifier,
0236   IntrinsicFunctionIdentifier,
0237   ConversionOperatorIdentifier,
0238   DynamicStructorIdentifier,
0239   StructorIdentifier,
0240   LiteralOperatorIdentifier,
0241   ThunkSignature,
0242   PointerType,
0243   TagType,
0244   ArrayType,
0245   Custom,
0246   IntrinsicType,
0247   NodeArray,
0248   QualifiedName,
0249   TemplateParameterReference,
0250   EncodedStringLiteral,
0251   IntegerLiteral,
0252   RttiBaseClassDescriptor,
0253   LocalStaticGuardVariable,
0254   FunctionSymbol,
0255   VariableSymbol,
0256   SpecialTableSymbol
0257 };
0258
0259 struct Node {
0260   explicit Node(NodeKind K) : Kind(K) {}
0261   virtual ~Node() = default;
0262
0263   NodeKind kind() const { return Kind; }
0264
0265   virtual void output(OutputBuffer &OB, OutputFlags Flags) const = 0;
0266
0267   std::string toString(OutputFlags Flags = OF_Default) const;
0268
0269 private:
0270   NodeKind Kind;
0271 };
0272
0273 struct TypeNode;
0274 struct PrimitiveTypeNode;
0275 struct FunctionSignatureNode;
0276 struct IdentifierNode;
0277 struct NamedIdentifierNode;
0278 struct VcallThunkIdentifierNode;
0279 struct IntrinsicFunctionIdentifierNode;
0280 struct LiteralOperatorIdentifierNode;
0281 struct ConversionOperatorIdentifierNode;
0282 struct StructorIdentifierNode;
0283 struct ThunkSignatureNode;
0284 struct PointerTypeNode;
0285 struct ArrayTypeNode;
0286 struct TagTypeNode;
0287 struct NodeArrayNode;
0288 struct QualifiedNameNode;
0289 struct TemplateParameterReferenceNode;
0290 struct EncodedStringLiteralNode;
0291 struct IntegerLiteralNode;
0292 struct RttiBaseClassDescriptorNode;
0293 struct LocalStaticGuardVariableNode;
0294 struct SymbolNode;
0295 struct FunctionSymbolNode;
0296 struct VariableSymbolNode;
0297 struct SpecialTableSymbolNode;
0298
0299 struct TypeNode : public Node {
0300   explicit TypeNode(NodeKind K) : Node(K) {}
0301
0302   virtual void outputPre(OutputBuffer &OB, OutputFlags Flags) const = 0;
0303   virtual void outputPost(OutputBuffer &OB, OutputFlags Flags) const = 0;
0304
0305   void output(OutputBuffer &OB, OutputFlags Flags) const override {
0306     outputPre(OB, Flags);
0307     outputPost(OB, Flags);
0308   }
0309
0310   Qualifiers Quals = Q_None;
0311 };
0312
0313 struct PrimitiveTypeNode : public TypeNode {
0314   explicit PrimitiveTypeNode(PrimitiveKind K)
0315       : TypeNode(NodeKind::PrimitiveType), PrimKind(K) {}
0316
0317   void outputPre(OutputBuffer &OB, OutputFlags Flags) const override;
0318   void outputPost(OutputBuffer &OB, OutputFlags Flags) const override {}
0319
0320   PrimitiveKind PrimKind;
0321 };
0322
0323 struct FunctionSignatureNode : public TypeNode {
0324   explicit FunctionSignatureNode(NodeKind K) : TypeNode(K) {}
0325   FunctionSignatureNode() : TypeNode(NodeKind::FunctionSignature) {}
0326
0327   void outputPre(OutputBuffer &OB, OutputFlags Flags) const override;
0328   void outputPost(OutputBuffer &OB, OutputFlags Flags) const override;
0329
0330   // Valid if this FunctionTypeNode is the Pointee of a PointerType or
0331   // MemberPointerType.
0332   PointerAffinity Affinity = PointerAffinity::None;
0333
0334   // The function's calling convention.
0335   CallingConv CallConvention = CallingConv::None;
0336
0337   // Function flags (global, public, etc)
0338   FuncClass FunctionClass = FC_Global;
0339
0340   FunctionRefQualifier RefQualifier = FunctionRefQualifier::None;
0341
0342   // The return type of the function.
0343   TypeNode *ReturnType = nullptr;
0344
0345   // True if this is a C-style ... varargs function.
0346   bool IsVariadic = false;
0347
0348   // Function parameters
0349   NodeArrayNode *Params = nullptr;
0350
0351   // True if the function type is noexcept.
0352   bool IsNoexcept = false;
0353 };
0354
0355 struct IdentifierNode : public Node {
0356   explicit IdentifierNode(NodeKind K) : Node(K) {}
0357
0358   NodeArrayNode *TemplateParams = nullptr;
0359
0360 protected:
0361   void outputTemplateParameters(OutputBuffer &OB, OutputFlags Flags) const;
0362 };
0363
0364 struct VcallThunkIdentifierNode : public IdentifierNode {
0365   VcallThunkIdentifierNode() : IdentifierNode(NodeKind::VcallThunkIdentifier) {}
0366
0367   void output(OutputBuffer &OB, OutputFlags Flags) const override;
0368
0369   uint64_t OffsetInVTable = 0;
0370 };
0371
0372 struct DynamicStructorIdentifierNode : public IdentifierNode {
0373   DynamicStructorIdentifierNode()
0374       : IdentifierNode(NodeKind::DynamicStructorIdentifier) {}
0375
0376   void output(OutputBuffer &OB, OutputFlags Flags) const override;
0377
0378   VariableSymbolNode *Variable = nullptr;
0379   QualifiedNameNode *Name = nullptr;
0380   bool IsDestructor = false;
0381 };
0382
0383 struct NamedIdentifierNode : public IdentifierNode {
0384   NamedIdentifierNode() : IdentifierNode(NodeKind::NamedIdentifier) {}
0385
0386   void output(OutputBuffer &OB, OutputFlags Flags) const override;
0387
0388   std::string_view Name;
0389 };
0390
0391 struct IntrinsicFunctionIdentifierNode : public IdentifierNode {
0392   explicit IntrinsicFunctionIdentifierNode(IntrinsicFunctionKind Operator)
0393       : IdentifierNode(NodeKind::IntrinsicFunctionIdentifier),
0394         Operator(Operator) {}
0395
0396   void output(OutputBuffer &OB, OutputFlags Flags) const override;
0397
0398   IntrinsicFunctionKind Operator;
0399 };
0400
0401 struct LiteralOperatorIdentifierNode : public IdentifierNode {
0402   LiteralOperatorIdentifierNode()
0403       : IdentifierNode(NodeKind::LiteralOperatorIdentifier) {}
0404
0405   void output(OutputBuffer &OB, OutputFlags Flags) const override;
0406
0407   std::string_view Name;
0408 };
0409
0410 struct LocalStaticGuardIdentifierNode : public IdentifierNode {
0411   LocalStaticGuardIdentifierNode()
0412       : IdentifierNode(NodeKind::LocalStaticGuardIdentifier) {}
0413
0414   void output(OutputBuffer &OB, OutputFlags Flags) const override;
0415
0416   bool IsThread = false;
0417   uint32_t ScopeIndex = 0;
0418 };
0419
0420 struct ConversionOperatorIdentifierNode : public IdentifierNode {
0421   ConversionOperatorIdentifierNode()
0422       : IdentifierNode(NodeKind::ConversionOperatorIdentifier) {}
0423
0424   void output(OutputBuffer &OB, OutputFlags Flags) const override;
0425
0426   // The type that this operator converts too.
0427   TypeNode *TargetType = nullptr;
0428 };
0429
0430 struct StructorIdentifierNode : public IdentifierNode {
0431   StructorIdentifierNode() : IdentifierNode(NodeKind::StructorIdentifier) {}
0432   explicit StructorIdentifierNode(bool IsDestructor)
0433       : IdentifierNode(NodeKind::StructorIdentifier),
0434         IsDestructor(IsDestructor) {}
0435
0436   void output(OutputBuffer &OB, OutputFlags Flags) const override;
0437
0438   // The name of the class that this is a structor of.
0439   IdentifierNode *Class = nullptr;
0440   bool IsDestructor = false;
0441 };
0442
0443 struct ThunkSignatureNode : public FunctionSignatureNode {
0444   ThunkSignatureNode() : FunctionSignatureNode(NodeKind::ThunkSignature) {}
0445
0446   void outputPre(OutputBuffer &OB, OutputFlags Flags) const override;
0447   void outputPost(OutputBuffer &OB, OutputFlags Flags) const override;
0448
0449   struct ThisAdjustor {
0450     uint32_t StaticOffset = 0;
0451     int32_t VBPtrOffset = 0;
0452     int32_t VBOffsetOffset = 0;
0453     int32_t VtordispOffset = 0;
0454   };
0455
0456   ThisAdjustor ThisAdjust;
0457 };
0458
0459 struct PointerTypeNode : public TypeNode {
0460   PointerTypeNode() : TypeNode(NodeKind::PointerType) {}
0461   void outputPre(OutputBuffer &OB, OutputFlags Flags) const override;
0462   void outputPost(OutputBuffer &OB, OutputFlags Flags) const override;
0463
0464   // Is this a pointer, reference, or rvalue-reference?
0465   PointerAffinity Affinity = PointerAffinity::None;
0466
0467   // If this is a member pointer, this is the class that the member is in.
0468   QualifiedNameNode *ClassParent = nullptr;
0469
0470   // Represents a type X in "a pointer to X", "a reference to X", or
0471   // "rvalue-reference to X"
0472   TypeNode *Pointee = nullptr;
0473 };
0474
0475 struct TagTypeNode : public TypeNode {
0476   explicit TagTypeNode(TagKind Tag) : TypeNode(NodeKind::TagType), Tag(Tag) {}
0477
0478   void outputPre(OutputBuffer &OB, OutputFlags Flags) const override;
0479   void outputPost(OutputBuffer &OB, OutputFlags Flags) const override;
0480
0481   QualifiedNameNode *QualifiedName = nullptr;
0482   TagKind Tag;
0483 };
0484
0485 struct ArrayTypeNode : public TypeNode {
0486   ArrayTypeNode() : TypeNode(NodeKind::ArrayType) {}
0487
0488   void outputPre(OutputBuffer &OB, OutputFlags Flags) const override;
0489   void outputPost(OutputBuffer &OB, OutputFlags Flags) const override;
0490
0491   void outputDimensionsImpl(OutputBuffer &OB, OutputFlags Flags) const;
0492   void outputOneDimension(OutputBuffer &OB, OutputFlags Flags, Node *N) const;
0493
0494   // A list of array dimensions.  e.g. [3,4,5] in `int Foo[3][4][5]`
0495   NodeArrayNode *Dimensions = nullptr;
0496
0497   // The type of array element.
0498   TypeNode *ElementType = nullptr;
0499 };
0500
0501 struct IntrinsicNode : public TypeNode {
0502   IntrinsicNode() : TypeNode(NodeKind::IntrinsicType) {}
0503   void output(OutputBuffer &OB, OutputFlags Flags) const override {}
0504 };
0505
0506 struct CustomTypeNode : public TypeNode {
0507   CustomTypeNode() : TypeNode(NodeKind::Custom) {}
0508
0509   void outputPre(OutputBuffer &OB, OutputFlags Flags) const override;
0510   void outputPost(OutputBuffer &OB, OutputFlags Flags) const override;
0511
0512   IdentifierNode *Identifier = nullptr;
0513 };
0514
0515 struct NodeArrayNode : public Node {
0516   NodeArrayNode() : Node(NodeKind::NodeArray) {}
0517
0518   void output(OutputBuffer &OB, OutputFlags Flags) const override;
0519
0520   void output(OutputBuffer &OB, OutputFlags Flags,
0521               std::string_view Separator) const;
0522
0523   Node **Nodes = nullptr;
0524   size_t Count = 0;
0525 };
0526
0527 struct QualifiedNameNode : public Node {
0528   QualifiedNameNode() : Node(NodeKind::QualifiedName) {}
0529
0530   void output(OutputBuffer &OB, OutputFlags Flags) const override;
0531
0532   NodeArrayNode *Components = nullptr;
0533
0534   IdentifierNode *getUnqualifiedIdentifier() {
0535     Node *LastComponent = Components->Nodes[Components->Count - 1];
0536     return static_cast<IdentifierNode *>(LastComponent);
0537   }
0538 };
0539
0540 struct TemplateParameterReferenceNode : public Node {
0541   TemplateParameterReferenceNode()
0542       : Node(NodeKind::TemplateParameterReference) {}
0543
0544   void output(OutputBuffer &OB, OutputFlags Flags) const override;
0545
0546   SymbolNode *Symbol = nullptr;
0547
0548   int ThunkOffsetCount = 0;
0549   std::array<int64_t, 3> ThunkOffsets;
0550   PointerAffinity Affinity = PointerAffinity::None;
0551   bool IsMemberPointer = false;
0552 };
0553
0554 struct IntegerLiteralNode : public Node {
0555   IntegerLiteralNode() : Node(NodeKind::IntegerLiteral) {}
0556   IntegerLiteralNode(uint64_t Value, bool IsNegative)
0557       : Node(NodeKind::IntegerLiteral), Value(Value), IsNegative(IsNegative) {}
0558
0559   void output(OutputBuffer &OB, OutputFlags Flags) const override;
0560
0561   uint64_t Value = 0;
0562   bool IsNegative = false;
0563 };
0564
0565 struct RttiBaseClassDescriptorNode : public IdentifierNode {
0566   RttiBaseClassDescriptorNode()
0567       : IdentifierNode(NodeKind::RttiBaseClassDescriptor) {}
0568
0569   void output(OutputBuffer &OB, OutputFlags Flags) const override;
0570
0571   uint32_t NVOffset = 0;
0572   int32_t VBPtrOffset = 0;
0573   uint32_t VBTableOffset = 0;
0574   uint32_t Flags = 0;
0575 };
0576
0577 struct SymbolNode : public Node {
0578   explicit SymbolNode(NodeKind K) : Node(K) {}
0579   void output(OutputBuffer &OB, OutputFlags Flags) const override;
0580   QualifiedNameNode *Name = nullptr;
0581 };
0582
0583 struct SpecialTableSymbolNode : public SymbolNode {
0584   explicit SpecialTableSymbolNode()
0585       : SymbolNode(NodeKind::SpecialTableSymbol) {}
0586
0587   void output(OutputBuffer &OB, OutputFlags Flags) const override;
0588   QualifiedNameNode *TargetName = nullptr;
0589   Qualifiers Quals = Qualifiers::Q_None;
0590 };
0591
0592 struct LocalStaticGuardVariableNode : public SymbolNode {
0593   LocalStaticGuardVariableNode()
0594       : SymbolNode(NodeKind::LocalStaticGuardVariable) {}
0595
0596   void output(OutputBuffer &OB, OutputFlags Flags) const override;
0597
0598   bool IsVisible = false;
0599 };
0600
0601 struct EncodedStringLiteralNode : public SymbolNode {
0602   EncodedStringLiteralNode() : SymbolNode(NodeKind::EncodedStringLiteral) {}
0603
0604   void output(OutputBuffer &OB, OutputFlags Flags) const override;
0605
0606   std::string_view DecodedString;
0607   bool IsTruncated = false;
0608   CharKind Char = CharKind::Char;
0609 };
0610
0611 struct VariableSymbolNode : public SymbolNode {
0612   VariableSymbolNode() : SymbolNode(NodeKind::VariableSymbol) {}
0613
0614   void output(OutputBuffer &OB, OutputFlags Flags) const override;
0615
0616   StorageClass SC = StorageClass::None;
0617   TypeNode *Type = nullptr;
0618 };
0619
0620 struct FunctionSymbolNode : public SymbolNode {
0621   FunctionSymbolNode() : SymbolNode(NodeKind::FunctionSymbol) {}
0622
0623   void output(OutputBuffer &OB, OutputFlags Flags) const override;
0624
0625   FunctionSignatureNode *Signature = nullptr;
0626 };
0627
0628 } // namespace ms_demangle
0629 } // namespace llvm
0630
0631 #endif