llvm/lib/Demangle/MicrosoftDemangleNodes.cpp

   1 //===- MicrosoftDemangle.cpp ----------------------------------------------===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8 //
   9 // This file defines a demangler for MSVC-style mangled symbols.
  10 //
  11 //===----------------------------------------------------------------------===//
  12
  13 #include "llvm/Demangle/MicrosoftDemangleNodes.h"
  14 #include "llvm/Demangle/Utility.h"
  15 #include <cctype>
  16 #include <string>
  17
  18 using namespace llvm;
  19 using namespace ms_demangle;
  20
  21 #define OUTPUT_ENUM_CLASS_VALUE(Enum, Value, Desc)                             \
  22   case Enum::Value:                                                            \
  23     OB << Desc;                                                                \
  24     break;
  25
  26 // Writes a space if the last token does not end with a punctuation.
  27 static void outputSpaceIfNecessary(OutputBuffer &OB) {
  28   if (OB.empty())
  29     return;
  30
  31   char C = OB.back();
  32   if (std::isalnum(C) || C == '>')
  33     OB << " ";
  34 }
  35
  36 static void outputSingleQualifier(OutputBuffer &OB, Qualifiers Q) {
  37   switch (Q) {
  38   case Q_Const:
  39     OB << "const";
  40     break;
  41   case Q_Volatile:
  42     OB << "volatile";
  43     break;
  44   case Q_Restrict:
  45     OB << "__restrict";
  46     break;
  47   default:
  48     break;
  49   }
  50 }
  51
  52 static bool outputQualifierIfPresent(OutputBuffer &OB, Qualifiers Q,
  53                                      Qualifiers Mask, bool NeedSpace) {
  54   if (!(Q & Mask))
  55     return NeedSpace;
  56
  57   if (NeedSpace)
  58     OB << " ";
  59
  60   outputSingleQualifier(OB, Mask);
  61   return true;
  62 }
  63
  64 static void outputQualifiers(OutputBuffer &OB, Qualifiers Q, bool SpaceBefore,
  65                              bool SpaceAfter) {
  66   if (Q == Q_None)
  67     return;
  68
  69   size_t Pos1 = OB.getCurrentPosition();
  70   SpaceBefore = outputQualifierIfPresent(OB, Q, Q_Const, SpaceBefore);
  71   SpaceBefore = outputQualifierIfPresent(OB, Q, Q_Volatile, SpaceBefore);
  72   SpaceBefore = outputQualifierIfPresent(OB, Q, Q_Restrict, SpaceBefore);
  73   size_t Pos2 = OB.getCurrentPosition();
  74   if (SpaceAfter && Pos2 > Pos1)
  75     OB << " ";
  76 }
  77
  78 static void outputCallingConvention(OutputBuffer &OB, CallingConv CC) {
  79   outputSpaceIfNecessary(OB);
  80
  81   switch (CC) {
  82   case CallingConv::Cdecl:
  83     OB << "__cdecl";
  84     break;
  85   case CallingConv::Fastcall:
  86     OB << "__fastcall";
  87     break;
  88   case CallingConv::Pascal:
  89     OB << "__pascal";
  90     break;
  91   case CallingConv::Regcall:
  92     OB << "__regcall";
  93     break;
  94   case CallingConv::Stdcall:
  95     OB << "__stdcall";
  96     break;
  97   case CallingConv::Thiscall:
  98     OB << "__thiscall";
  99     break;
 100   case CallingConv::Eabi:
 101     OB << "__eabi";
 102     break;
 103   case CallingConv::Vectorcall:
 104     OB << "__vectorcall";
 105     break;
 106   case CallingConv::Clrcall:
 107     OB << "__clrcall";
 108     break;
 109   case CallingConv::Swift:
 110     OB << "__attribute__((__swiftcall__)) ";
 111     break;
 112   case CallingConv::SwiftAsync:
 113     OB << "__attribute__((__swiftasynccall__)) ";
 114     break;
 115   default:
 116     break;
 117   }
 118 }
 119
 120 std::string Node::toString(OutputFlags Flags) const {
 121   OutputBuffer OB;
 122   this->output(OB, Flags);
 123   std::string_view SV = OB;
 124   std::string Owned(SV.begin(), SV.end());
 125   std::free(OB.getBuffer());
 126   return Owned;
 127 }
 128
 129 void PrimitiveTypeNode::outputPre(OutputBuffer &OB, OutputFlags Flags) const {
 130   switch (PrimKind) {
 131     OUTPUT_ENUM_CLASS_VALUE(PrimitiveKind, Void, "void");
 132     OUTPUT_ENUM_CLASS_VALUE(PrimitiveKind, Bool, "bool");
 133     OUTPUT_ENUM_CLASS_VALUE(PrimitiveKind, Char, "char");
 134     OUTPUT_ENUM_CLASS_VALUE(PrimitiveKind, Schar, "signed char");
 135     OUTPUT_ENUM_CLASS_VALUE(PrimitiveKind, Uchar, "unsigned char");
 136     OUTPUT_ENUM_CLASS_VALUE(PrimitiveKind, Char8, "char8_t");
 137     OUTPUT_ENUM_CLASS_VALUE(PrimitiveKind, Char16, "char16_t");
 138     OUTPUT_ENUM_CLASS_VALUE(PrimitiveKind, Char32, "char32_t");
 139     OUTPUT_ENUM_CLASS_VALUE(PrimitiveKind, Short, "short");
 140     OUTPUT_ENUM_CLASS_VALUE(PrimitiveKind, Ushort, "unsigned short");
 141     OUTPUT_ENUM_CLASS_VALUE(PrimitiveKind, Int, "int");
 142     OUTPUT_ENUM_CLASS_VALUE(PrimitiveKind, Uint, "unsigned int");
 143     OUTPUT_ENUM_CLASS_VALUE(PrimitiveKind, Long, "long");
 144     OUTPUT_ENUM_CLASS_VALUE(PrimitiveKind, Ulong, "unsigned long");
 145     OUTPUT_ENUM_CLASS_VALUE(PrimitiveKind, Int64, "__int64");
 146     OUTPUT_ENUM_CLASS_VALUE(PrimitiveKind, Uint64, "unsigned __int64");
 147     OUTPUT_ENUM_CLASS_VALUE(PrimitiveKind, Wchar, "wchar_t");
 148     OUTPUT_ENUM_CLASS_VALUE(PrimitiveKind, Float, "float");
 149     OUTPUT_ENUM_CLASS_VALUE(PrimitiveKind, Double, "double");
 150     OUTPUT_ENUM_CLASS_VALUE(PrimitiveKind, Ldouble, "long double");
 151     OUTPUT_ENUM_CLASS_VALUE(PrimitiveKind, Nullptr, "std::nullptr_t");
 152   }
 153   outputQualifiers(OB, Quals, true, false);
 154 }
 155
 156 void NodeArrayNode::output(OutputBuffer &OB, OutputFlags Flags) const {
 157   output(OB, Flags, ", ");
 158 }
 159
 160 void NodeArrayNode::output(OutputBuffer &OB, OutputFlags Flags,
 161                            std::string_view Separator) const {
 162   if (Count == 0)
 163     return;
 164   if (Nodes[0])
 165     Nodes[0]->output(OB, Flags);
 166   for (size_t I = 1; I < Count; ++I) {
 167     OB << Separator;
 168     Nodes[I]->output(OB, Flags);
 169   }
 170 }
 171
 172 void EncodedStringLiteralNode::output(OutputBuffer &OB,
 173                                       OutputFlags Flags) const {
 174   switch (Char) {
 175   case CharKind::Wchar:
 176     OB << "L\"";
 177     break;
 178   case CharKind::Char:
 179     OB << "\"";
 180     break;
 181   case CharKind::Char16:
 182     OB << "u\"";
 183     break;
 184   case CharKind::Char32:
 185     OB << "U\"";
 186     break;
 187   }
 188   OB << DecodedString << "\"";
 189   if (IsTruncated)
 190     OB << "...";
 191 }
 192
 193 void IntegerLiteralNode::output(OutputBuffer &OB, OutputFlags Flags) const {
 194   if (IsNegative)
 195     OB << '-';
 196   OB << Value;
 197 }
 198
 199 void TemplateParameterReferenceNode::output(OutputBuffer &OB,
 200                                             OutputFlags Flags) const {
 201   if (ThunkOffsetCount > 0)
 202     OB << "{";
 203   else if (Affinity == PointerAffinity::Pointer)
 204     OB << "&";
 205
 206   if (Symbol) {
 207     Symbol->output(OB, Flags);
 208     if (ThunkOffsetCount > 0)
 209       OB << ", ";
 210   }
 211
 212   if (ThunkOffsetCount > 0)
 213     OB << ThunkOffsets[0];
 214   for (int I = 1; I < ThunkOffsetCount; ++I) {
 215     OB << ", " << ThunkOffsets[I];
 216   }
 217   if (ThunkOffsetCount > 0)
 218     OB << "}";
 219 }
 220
 221 void IdentifierNode::outputTemplateParameters(OutputBuffer &OB,
 222                                               OutputFlags Flags) const {
 223   if (!TemplateParams)
 224     return;
 225   OB << "<";
 226   TemplateParams->output(OB, Flags);
 227   OB << ">";
 228 }
 229
 230 void DynamicStructorIdentifierNode::output(OutputBuffer &OB,
 231                                            OutputFlags Flags) const {
 232   if (IsDestructor)
 233     OB << "`dynamic atexit destructor for ";
 234   else
 235     OB << "`dynamic initializer for ";
 236
 237   if (Variable) {
 238     OB << "`";
 239     Variable->output(OB, Flags);
 240     OB << "''";
 241   } else {
 242     OB << "'";
 243     Name->output(OB, Flags);
 244     OB << "''";
 245   }
 246 }
 247
 248 void NamedIdentifierNode::output(OutputBuffer &OB, OutputFlags Flags) const {
 249   OB << Name;
 250   outputTemplateParameters(OB, Flags);
 251 }
 252
 253 void IntrinsicFunctionIdentifierNode::output(OutputBuffer &OB,
 254                                              OutputFlags Flags) const {
 255   switch (Operator) {
 256     OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, New, "operator new");
 257     OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, Delete, "operator delete");
 258     OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, Assign, "operator=");
 259     OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, RightShift, "operator>>");
 260     OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, LeftShift, "operator<<");
 261     OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, LogicalNot, "operator!");
 262     OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, Equals, "operator==");
 263     OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, NotEquals, "operator!=");
 264     OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, ArraySubscript,
 265                             "operator[]");
 266     OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, Pointer, "operator->");
 267     OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, Increment, "operator++");
 268     OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, Decrement, "operator--");
 269     OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, Minus, "operator-");
 270     OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, Plus, "operator+");
 271     OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, Dereference, "operator*");
 272     OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, BitwiseAnd, "operator&");
 273     OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, MemberPointer,
 274                             "operator->*");
 275     OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, Divide, "operator/");
 276     OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, Modulus, "operator%");
 277     OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, LessThan, "operator<");
 278     OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, LessThanEqual, "operator<=");
 279     OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, GreaterThan, "operator>");
 280     OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, GreaterThanEqual,
 281                             "operator>=");
 282     OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, Comma, "operator,");
 283     OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, Parens, "operator()");
 284     OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, BitwiseNot, "operator~");
 285     OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, BitwiseXor, "operator^");
 286     OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, BitwiseOr, "operator|");
 287     OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, LogicalAnd, "operator&&");
 288     OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, LogicalOr, "operator||");
 289     OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, TimesEqual, "operator*=");
 290     OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, PlusEqual, "operator+=");
 291     OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, MinusEqual, "operator-=");
 292     OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, DivEqual, "operator/=");
 293     OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, ModEqual, "operator%=");
 294     OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, RshEqual, "operator>>=");
 295     OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, LshEqual, "operator<<=");
 296     OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, BitwiseAndEqual,
 297                             "operator&=");
 298     OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, BitwiseOrEqual,
 299                             "operator|=");
 300     OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, BitwiseXorEqual,
 301                             "operator^=");
 302     OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, VbaseDtor, "`vbase dtor'");
 303     OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, VecDelDtor,
 304                             "`vector deleting dtor'");
 305     OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, DefaultCtorClosure,
 306                             "`default ctor closure'");
 307     OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, ScalarDelDtor,
 308                             "`scalar deleting dtor'");
 309     OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, VecCtorIter,
 310                             "`vector ctor iterator'");
 311     OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, VecDtorIter,
 312                             "`vector dtor iterator'");
 313     OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, VecVbaseCtorIter,
 314                             "`vector vbase ctor iterator'");
 315     OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, VdispMap,
 316                             "`virtual displacement map'");
 317     OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, EHVecCtorIter,
 318                             "`eh vector ctor iterator'");
 319     OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, EHVecDtorIter,
 320                             "`eh vector dtor iterator'");
 321     OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, EHVecVbaseCtorIter,
 322                             "`eh vector vbase ctor iterator'");
 323     OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, CopyCtorClosure,
 324                             "`copy ctor closure'");
 325     OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, LocalVftableCtorClosure,
 326                             "`local vftable ctor closure'");
 327     OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, ArrayNew, "operator new[]");
 328     OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, ArrayDelete,
 329                             "operator delete[]");
 330     OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, ManVectorCtorIter,
 331                             "`managed vector ctor iterator'");
 332     OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, ManVectorDtorIter,
 333                             "`managed vector dtor iterator'");
 334     OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, EHVectorCopyCtorIter,
 335                             "`EH vector copy ctor iterator'");
 336     OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, EHVectorVbaseCopyCtorIter,
 337                             "`EH vector vbase copy ctor iterator'");
 338     OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, VectorCopyCtorIter,
 339                             "`vector copy ctor iterator'");
 340     OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, VectorVbaseCopyCtorIter,
 341                             "`vector vbase copy constructor iterator'");
 342     OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, ManVectorVbaseCopyCtorIter,
 343                             "`managed vector vbase copy constructor iterator'");
 344     OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, CoAwait,
 345                             "operator co_await");
 346     OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, Spaceship, "operator<=>");
 347   case IntrinsicFunctionKind::MaxIntrinsic:
 348   case IntrinsicFunctionKind::None:
 349     break;
 350   }
 351   outputTemplateParameters(OB, Flags);
 352 }
 353
 354 void LocalStaticGuardIdentifierNode::output(OutputBuffer &OB,
 355                                             OutputFlags Flags) const {
 356   if (IsThread)
 357     OB << "`local static thread guard'";
 358   else
 359     OB << "`local static guard'";
 360   if (ScopeIndex > 0)
 361     OB << "{" << ScopeIndex << "}";
 362 }
 363
 364 void ConversionOperatorIdentifierNode::output(OutputBuffer &OB,
 365                                               OutputFlags Flags) const {
 366   OB << "operator";
 367   outputTemplateParameters(OB, Flags);
 368   OB << " ";
 369   TargetType->output(OB, Flags);
 370 }
 371
 372 void StructorIdentifierNode::output(OutputBuffer &OB, OutputFlags Flags) const {
 373   if (IsDestructor)
 374     OB << "~";
 375   Class->output(OB, Flags);
 376   outputTemplateParameters(OB, Flags);
 377 }
 378
 379 void LiteralOperatorIdentifierNode::output(OutputBuffer &OB,
 380                                            OutputFlags Flags) const {
 381   OB << "operator \"\"" << Name;
 382   outputTemplateParameters(OB, Flags);
 383 }
 384
 385 void FunctionSignatureNode::outputPre(OutputBuffer &OB,
 386                                       OutputFlags Flags) const {
 387   if (!(Flags & OF_NoAccessSpecifier)) {
 388     if (FunctionClass & FC_Public)
 389       OB << "public: ";
 390     if (FunctionClass & FC_Protected)
 391       OB << "protected: ";
 392     if (FunctionClass & FC_Private)
 393       OB << "private: ";
 394   }
 395
 396   if (!(Flags & OF_NoMemberType)) {
 397     if (!(FunctionClass & FC_Global)) {
 398       if (FunctionClass & FC_Static)
 399         OB << "static ";
 400     }
 401     if (FunctionClass & FC_Virtual)
 402       OB << "virtual ";
 403
 404     if (FunctionClass & FC_ExternC)
 405       OB << "extern \"C\" ";
 406   }
 407
 408   if (!(Flags & OF_NoReturnType) && ReturnType) {
 409     ReturnType->outputPre(OB, Flags);
 410     OB << " ";
 411   }
 412
 413   if (!(Flags & OF_NoCallingConvention))
 414     outputCallingConvention(OB, CallConvention);
 415 }
 416
 417 void FunctionSignatureNode::outputPost(OutputBuffer &OB,
 418                                        OutputFlags Flags) const {
 419   if (!(FunctionClass & FC_NoParameterList)) {
 420     OB << "(";
 421     if (Params)
 422       Params->output(OB, Flags);
 423     else
 424       OB << "void";
 425
 426     if (IsVariadic) {
 427       if (OB.back() != '(')
 428         OB << ", ";
 429       OB << "...";
 430     }
 431     OB << ")";
 432   }
 433
 434   if (Quals & Q_Const)
 435     OB << " const";
 436   if (Quals & Q_Volatile)
 437     OB << " volatile";
 438   if (Quals & Q_Restrict)
 439     OB << " __restrict";
 440   if (Quals & Q_Unaligned)
 441     OB << " __unaligned";
 442
 443   if (IsNoexcept)
 444     OB << " noexcept";
 445
 446   if (RefQualifier == FunctionRefQualifier::Reference)
 447     OB << " &";
 448   else if (RefQualifier == FunctionRefQualifier::RValueReference)
 449     OB << " &&";
 450
 451   if (!(Flags & OF_NoReturnType) && ReturnType)
 452     ReturnType->outputPost(OB, Flags);
 453 }
 454
 455 void ThunkSignatureNode::outputPre(OutputBuffer &OB, OutputFlags Flags) const {
 456   OB << "[thunk]: ";
 457
 458   FunctionSignatureNode::outputPre(OB, Flags);
 459 }
 460
 461 void ThunkSignatureNode::outputPost(OutputBuffer &OB, OutputFlags Flags) const {
 462   if (FunctionClass & FC_StaticThisAdjust) {
 463     OB << "`adjustor{" << ThisAdjust.StaticOffset << "}'";
 464   } else if (FunctionClass & FC_VirtualThisAdjust) {
 465     if (FunctionClass & FC_VirtualThisAdjustEx) {
 466       OB << "`vtordispex{" << ThisAdjust.VBPtrOffset << ", "
 467          << ThisAdjust.VBOffsetOffset << ", " << ThisAdjust.VtordispOffset
 468          << ", " << ThisAdjust.StaticOffset << "}'";
 469     } else {
 470       OB << "`vtordisp{" << ThisAdjust.VtordispOffset << ", "
 471          << ThisAdjust.StaticOffset << "}'";
 472     }
 473   }
 474
 475   FunctionSignatureNode::outputPost(OB, Flags);
 476 }
 477
 478 void PointerTypeNode::outputPre(OutputBuffer &OB, OutputFlags Flags) const {
 479   if (Pointee->kind() == NodeKind::FunctionSignature) {
 480     // If this is a pointer to a function, don't output the calling convention.
 481     // It needs to go inside the parentheses.
 482     const FunctionSignatureNode *Sig =
 483         static_cast<const FunctionSignatureNode *>(Pointee);
 484     Sig->outputPre(OB, OF_NoCallingConvention);
 485   } else
 486     Pointee->outputPre(OB, Flags);
 487
 488   outputSpaceIfNecessary(OB);
 489
 490   if (Quals & Q_Unaligned)
 491     OB << "__unaligned ";
 492
 493   if (Pointee->kind() == NodeKind::ArrayType) {
 494     OB << "(";
 495   } else if (Pointee->kind() == NodeKind::FunctionSignature) {
 496     OB << "(";
 497     const FunctionSignatureNode *Sig =
 498         static_cast<const FunctionSignatureNode *>(Pointee);
 499     outputCallingConvention(OB, Sig->CallConvention);
 500     OB << " ";
 501   }
 502
 503   if (ClassParent) {
 504     ClassParent->output(OB, Flags);
 505     OB << "::";
 506   }
 507
 508   switch (Affinity) {
 509   case PointerAffinity::Pointer:
 510     OB << "*";
 511     break;
 512   case PointerAffinity::Reference:
 513     OB << "&";
 514     break;
 515   case PointerAffinity::RValueReference:
 516     OB << "&&";
 517     break;
 518   default:
 519     assert(false);
 520   }
 521   outputQualifiers(OB, Quals, false, false);
 522 }
 523
 524 void PointerTypeNode::outputPost(OutputBuffer &OB, OutputFlags Flags) const {
 525   if (Pointee->kind() == NodeKind::ArrayType ||
 526       Pointee->kind() == NodeKind::FunctionSignature)
 527     OB << ")";
 528
 529   Pointee->outputPost(OB, Flags);
 530 }
 531
 532 void TagTypeNode::outputPre(OutputBuffer &OB, OutputFlags Flags) const {
 533   if (!(Flags & OF_NoTagSpecifier)) {
 534     switch (Tag) {
 535       OUTPUT_ENUM_CLASS_VALUE(TagKind, Class, "class");
 536       OUTPUT_ENUM_CLASS_VALUE(TagKind, Struct, "struct");
 537       OUTPUT_ENUM_CLASS_VALUE(TagKind, Union, "union");
 538       OUTPUT_ENUM_CLASS_VALUE(TagKind, Enum, "enum");
 539     }
 540     OB << " ";
 541   }
 542   QualifiedName->output(OB, Flags);
 543   outputQualifiers(OB, Quals, true, false);
 544 }
 545
 546 void TagTypeNode::outputPost(OutputBuffer &OB, OutputFlags Flags) const {}
 547
 548 void ArrayTypeNode::outputPre(OutputBuffer &OB, OutputFlags Flags) const {
 549   ElementType->outputPre(OB, Flags);
 550   outputQualifiers(OB, Quals, true, false);
 551 }
 552
 553 void ArrayTypeNode::outputOneDimension(OutputBuffer &OB, OutputFlags Flags,
 554                                        Node *N) const {
 555   assert(N->kind() == NodeKind::IntegerLiteral);
 556   IntegerLiteralNode *ILN = static_cast<IntegerLiteralNode *>(N);
 557   if (ILN->Value != 0)
 558     ILN->output(OB, Flags);
 559 }
 560
 561 void ArrayTypeNode::outputDimensionsImpl(OutputBuffer &OB,
 562                                          OutputFlags Flags) const {
 563   if (Dimensions->Count == 0)
 564     return;
 565
 566   outputOneDimension(OB, Flags, Dimensions->Nodes[0]);
 567   for (size_t I = 1; I < Dimensions->Count; ++I) {
 568     OB << "][";
 569     outputOneDimension(OB, Flags, Dimensions->Nodes[I]);
 570   }
 571 }
 572
 573 void ArrayTypeNode::outputPost(OutputBuffer &OB, OutputFlags Flags) const {
 574   OB << "[";
 575   outputDimensionsImpl(OB, Flags);
 576   OB << "]";
 577
 578   ElementType->outputPost(OB, Flags);
 579 }
 580
 581 void SymbolNode::output(OutputBuffer &OB, OutputFlags Flags) const {
 582   Name->output(OB, Flags);
 583 }
 584
 585 void FunctionSymbolNode::output(OutputBuffer &OB, OutputFlags Flags) const {
 586   Signature->outputPre(OB, Flags);
 587   outputSpaceIfNecessary(OB);
 588   Name->output(OB, Flags);
 589   Signature->outputPost(OB, Flags);
 590 }
 591
 592 void VariableSymbolNode::output(OutputBuffer &OB, OutputFlags Flags) const {
 593   const char *AccessSpec = nullptr;
 594   bool IsStatic = true;
 595   switch (SC) {
 596   case StorageClass::PrivateStatic:
 597     AccessSpec = "private";
 598     break;
 599   case StorageClass::PublicStatic:
 600     AccessSpec = "public";
 601     break;
 602   case StorageClass::ProtectedStatic:
 603     AccessSpec = "protected";
 604     break;
 605   default:
 606     IsStatic = false;
 607     break;
 608   }
 609   if (!(Flags & OF_NoAccessSpecifier) && AccessSpec)
 610     OB << AccessSpec << ": ";
 611   if (!(Flags & OF_NoMemberType) && IsStatic)
 612     OB << "static ";
 613
 614   if (!(Flags & OF_NoVariableType) && Type) {
 615     Type->outputPre(OB, Flags);
 616     outputSpaceIfNecessary(OB);
 617   }
 618   Name->output(OB, Flags);
 619   if (!(Flags & OF_NoVariableType) && Type)
 620     Type->outputPost(OB, Flags);
 621 }
 622
 623 void CustomTypeNode::outputPre(OutputBuffer &OB, OutputFlags Flags) const {
 624   Identifier->output(OB, Flags);
 625 }
 626 void CustomTypeNode::outputPost(OutputBuffer &OB, OutputFlags Flags) const {}
 627
 628 void QualifiedNameNode::output(OutputBuffer &OB, OutputFlags Flags) const {
 629   Components->output(OB, Flags, "::");
 630 }
 631
 632 void RttiBaseClassDescriptorNode::output(OutputBuffer &OB,
 633                                          OutputFlags Flags) const {
 634   OB << "`RTTI Base Class Descriptor at (";
 635   OB << NVOffset << ", " << VBPtrOffset << ", " << VBTableOffset << ", "
 636      << this->Flags;
 637   OB << ")'";
 638 }
 639
 640 void LocalStaticGuardVariableNode::output(OutputBuffer &OB,
 641                                           OutputFlags Flags) const {
 642   Name->output(OB, Flags);
 643 }
 644
 645 void VcallThunkIdentifierNode::output(OutputBuffer &OB,
 646                                       OutputFlags Flags) const {
 647   OB << "`vcall'{" << OffsetInVTable << ", {flat}}";
 648 }
 649
 650 void SpecialTableSymbolNode::output(OutputBuffer &OB, OutputFlags Flags) const {
 651   outputQualifiers(OB, Quals, false, true);
 652   Name->output(OB, Flags);
 653   if (TargetName) {
 654     OB << "{for `";
 655     TargetName->output(OB, Flags);
 656     OB << "'}";
 657   }
 658 }