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     OUTPUT_ENUM_CLASS_VALUE(PrimitiveKind, Auto, "auto");
 153     OUTPUT_ENUM_CLASS_VALUE(PrimitiveKind, DecltypeAuto, "decltype(auto)");
 154   }
 155   outputQualifiers(OB, Quals, true, false);
 156 }
 157
 158 void NodeArrayNode::output(OutputBuffer &OB, OutputFlags Flags) const {
 159   output(OB, Flags, ", ");
 160 }
 161
 162 void NodeArrayNode::output(OutputBuffer &OB, OutputFlags Flags,
 163                            std::string_view Separator) const {
 164   if (Count == 0)
 165     return;
 166   if (Nodes[0])
 167     Nodes[0]->output(OB, Flags);
 168   for (size_t I = 1; I < Count; ++I) {
 169     OB << Separator;
 170     Nodes[I]->output(OB, Flags);
 171   }
 172 }
 173
 174 void EncodedStringLiteralNode::output(OutputBuffer &OB,
 175                                       OutputFlags Flags) const {
 176   switch (Char) {
 177   case CharKind::Wchar:
 178     OB << "L\"";
 179     break;
 180   case CharKind::Char:
 181     OB << "\"";
 182     break;
 183   case CharKind::Char16:
 184     OB << "u\"";
 185     break;
 186   case CharKind::Char32:
 187     OB << "U\"";
 188     break;
 189   }
 190   OB << DecodedString << "\"";
 191   if (IsTruncated)
 192     OB << "...";
 193 }
 194
 195 void IntegerLiteralNode::output(OutputBuffer &OB, OutputFlags Flags) const {
 196   if (IsNegative)
 197     OB << '-';
 198   OB << Value;
 199 }
 200
 201 void TemplateParameterReferenceNode::output(OutputBuffer &OB,
 202                                             OutputFlags Flags) const {
 203   if (ThunkOffsetCount > 0)
 204     OB << "{";
 205   else if (Affinity == PointerAffinity::Pointer)
 206     OB << "&";
 207
 208   if (Symbol) {
 209     Symbol->output(OB, Flags);
 210     if (ThunkOffsetCount > 0)
 211       OB << ", ";
 212   }
 213
 214   if (ThunkOffsetCount > 0)
 215     OB << ThunkOffsets[0];
 216   for (int I = 1; I < ThunkOffsetCount; ++I) {
 217     OB << ", " << ThunkOffsets[I];
 218   }
 219   if (ThunkOffsetCount > 0)
 220     OB << "}";
 221 }
 222
 223 void IdentifierNode::outputTemplateParameters(OutputBuffer &OB,
 224                                               OutputFlags Flags) const {
 225   if (!TemplateParams)
 226     return;
 227   OB << "<";
 228   TemplateParams->output(OB, Flags);
 229   OB << ">";
 230 }
 231
 232 void DynamicStructorIdentifierNode::output(OutputBuffer &OB,
 233                                            OutputFlags Flags) const {
 234   if (IsDestructor)
 235     OB << "`dynamic atexit destructor for ";
 236   else
 237     OB << "`dynamic initializer for ";
 238
 239   if (Variable) {
 240     OB << "`";
 241     Variable->output(OB, Flags);
 242     OB << "''";
 243   } else {
 244     OB << "'";
 245     Name->output(OB, Flags);
 246     OB << "''";
 247   }
 248 }
 249
 250 void NamedIdentifierNode::output(OutputBuffer &OB, OutputFlags Flags) const {
 251   OB << Name;
 252   outputTemplateParameters(OB, Flags);
 253 }
 254
 255 void IntrinsicFunctionIdentifierNode::output(OutputBuffer &OB,
 256                                              OutputFlags Flags) const {
 257   switch (Operator) {
 258     OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, New, "operator new");
 259     OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, Delete, "operator delete");
 260     OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, Assign, "operator=");
 261     OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, RightShift, "operator>>");
 262     OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, LeftShift, "operator<<");
 263     OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, LogicalNot, "operator!");
 264     OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, Equals, "operator==");
 265     OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, NotEquals, "operator!=");
 266     OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, ArraySubscript,
 267                             "operator[]");
 268     OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, Pointer, "operator->");
 269     OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, Increment, "operator++");
 270     OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, Decrement, "operator--");
 271     OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, Minus, "operator-");
 272     OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, Plus, "operator+");
 273     OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, Dereference, "operator*");
 274     OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, BitwiseAnd, "operator&");
 275     OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, MemberPointer,
 276                             "operator->*");
 277     OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, Divide, "operator/");
 278     OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, Modulus, "operator%");
 279     OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, LessThan, "operator<");
 280     OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, LessThanEqual, "operator<=");
 281     OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, GreaterThan, "operator>");
 282     OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, GreaterThanEqual,
 283                             "operator>=");
 284     OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, Comma, "operator,");
 285     OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, Parens, "operator()");
 286     OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, BitwiseNot, "operator~");
 287     OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, BitwiseXor, "operator^");
 288     OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, BitwiseOr, "operator|");
 289     OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, LogicalAnd, "operator&&");
 290     OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, LogicalOr, "operator||");
 291     OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, TimesEqual, "operator*=");
 292     OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, PlusEqual, "operator+=");
 293     OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, MinusEqual, "operator-=");
 294     OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, DivEqual, "operator/=");
 295     OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, ModEqual, "operator%=");
 296     OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, RshEqual, "operator>>=");
 297     OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, LshEqual, "operator<<=");
 298     OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, BitwiseAndEqual,
 299                             "operator&=");
 300     OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, BitwiseOrEqual,
 301                             "operator|=");
 302     OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, BitwiseXorEqual,
 303                             "operator^=");
 304     OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, VbaseDtor, "`vbase dtor'");
 305     OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, VecDelDtor,
 306                             "`vector deleting dtor'");
 307     OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, DefaultCtorClosure,
 308                             "`default ctor closure'");
 309     OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, ScalarDelDtor,
 310                             "`scalar deleting dtor'");
 311     OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, VecCtorIter,
 312                             "`vector ctor iterator'");
 313     OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, VecDtorIter,
 314                             "`vector dtor iterator'");
 315     OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, VecVbaseCtorIter,
 316                             "`vector vbase ctor iterator'");
 317     OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, VdispMap,
 318                             "`virtual displacement map'");
 319     OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, EHVecCtorIter,
 320                             "`eh vector ctor iterator'");
 321     OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, EHVecDtorIter,
 322                             "`eh vector dtor iterator'");
 323     OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, EHVecVbaseCtorIter,
 324                             "`eh vector vbase ctor iterator'");
 325     OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, CopyCtorClosure,
 326                             "`copy ctor closure'");
 327     OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, LocalVftableCtorClosure,
 328                             "`local vftable ctor closure'");
 329     OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, ArrayNew, "operator new[]");
 330     OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, ArrayDelete,
 331                             "operator delete[]");
 332     OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, ManVectorCtorIter,
 333                             "`managed vector ctor iterator'");
 334     OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, ManVectorDtorIter,
 335                             "`managed vector dtor iterator'");
 336     OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, EHVectorCopyCtorIter,
 337                             "`EH vector copy ctor iterator'");
 338     OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, EHVectorVbaseCopyCtorIter,
 339                             "`EH vector vbase copy ctor iterator'");
 340     OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, VectorCopyCtorIter,
 341                             "`vector copy ctor iterator'");
 342     OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, VectorVbaseCopyCtorIter,
 343                             "`vector vbase copy constructor iterator'");
 344     OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, ManVectorVbaseCopyCtorIter,
 345                             "`managed vector vbase copy constructor iterator'");
 346     OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, CoAwait,
 347                             "operator co_await");
 348     OUTPUT_ENUM_CLASS_VALUE(IntrinsicFunctionKind, Spaceship, "operator<=>");
 349   case IntrinsicFunctionKind::MaxIntrinsic:
 350   case IntrinsicFunctionKind::None:
 351     break;
 352   }
 353   outputTemplateParameters(OB, Flags);
 354 }
 355
 356 void LocalStaticGuardIdentifierNode::output(OutputBuffer &OB,
 357                                             OutputFlags Flags) const {
 358   if (IsThread)
 359     OB << "`local static thread guard'";
 360   else
 361     OB << "`local static guard'";
 362   if (ScopeIndex > 0)
 363     OB << "{" << ScopeIndex << "}";
 364 }
 365
 366 void ConversionOperatorIdentifierNode::output(OutputBuffer &OB,
 367                                               OutputFlags Flags) const {
 368   OB << "operator";
 369   outputTemplateParameters(OB, Flags);
 370   OB << " ";
 371   TargetType->output(OB, Flags);
 372 }
 373
 374 void StructorIdentifierNode::output(OutputBuffer &OB, OutputFlags Flags) const {
 375   if (IsDestructor)
 376     OB << "~";
 377   Class->output(OB, Flags);
 378   outputTemplateParameters(OB, Flags);
 379 }
 380
 381 void LiteralOperatorIdentifierNode::output(OutputBuffer &OB,
 382                                            OutputFlags Flags) const {
 383   OB << "operator \"\"" << Name;
 384   outputTemplateParameters(OB, Flags);
 385 }
 386
 387 void FunctionSignatureNode::outputPre(OutputBuffer &OB,
 388                                       OutputFlags Flags) const {
 389   if (!(Flags & OF_NoAccessSpecifier)) {
 390     if (FunctionClass & FC_Public)
 391       OB << "public: ";
 392     if (FunctionClass & FC_Protected)
 393       OB << "protected: ";
 394     if (FunctionClass & FC_Private)
 395       OB << "private: ";
 396   }
 397
 398   if (!(Flags & OF_NoMemberType)) {
 399     if (!(FunctionClass & FC_Global)) {
 400       if (FunctionClass & FC_Static)
 401         OB << "static ";
 402     }
 403     if (FunctionClass & FC_Virtual)
 404       OB << "virtual ";
 405
 406     if (FunctionClass & FC_ExternC)
 407       OB << "extern \"C\" ";
 408   }
 409
 410   if (!(Flags & OF_NoReturnType) && ReturnType) {
 411     ReturnType->outputPre(OB, Flags);
 412     OB << " ";
 413   }
 414
 415   if (!(Flags & OF_NoCallingConvention))
 416     outputCallingConvention(OB, CallConvention);
 417 }
 418
 419 void FunctionSignatureNode::outputPost(OutputBuffer &OB,
 420                                        OutputFlags Flags) const {
 421   if (!(FunctionClass & FC_NoParameterList)) {
 422     OB << "(";
 423     if (Params)
 424       Params->output(OB, Flags);
 425     else
 426       OB << "void";
 427
 428     if (IsVariadic) {
 429       if (OB.back() != '(')
 430         OB << ", ";
 431       OB << "...";
 432     }
 433     OB << ")";
 434   }
 435
 436   if (Quals & Q_Const)
 437     OB << " const";
 438   if (Quals & Q_Volatile)
 439     OB << " volatile";
 440   if (Quals & Q_Restrict)
 441     OB << " __restrict";
 442   if (Quals & Q_Unaligned)
 443     OB << " __unaligned";
 444
 445   if (IsNoexcept)
 446     OB << " noexcept";
 447
 448   if (RefQualifier == FunctionRefQualifier::Reference)
 449     OB << " &";
 450   else if (RefQualifier == FunctionRefQualifier::RValueReference)
 451     OB << " &&";
 452
 453   if (!(Flags & OF_NoReturnType) && ReturnType)
 454     ReturnType->outputPost(OB, Flags);
 455 }
 456
 457 void ThunkSignatureNode::outputPre(OutputBuffer &OB, OutputFlags Flags) const {
 458   OB << "[thunk]: ";
 459
 460   FunctionSignatureNode::outputPre(OB, Flags);
 461 }
 462
 463 void ThunkSignatureNode::outputPost(OutputBuffer &OB, OutputFlags Flags) const {
 464   if (FunctionClass & FC_StaticThisAdjust) {
 465     OB << "`adjustor{" << ThisAdjust.StaticOffset << "}'";
 466   } else if (FunctionClass & FC_VirtualThisAdjust) {
 467     if (FunctionClass & FC_VirtualThisAdjustEx) {
 468       OB << "`vtordispex{" << ThisAdjust.VBPtrOffset << ", "
 469          << ThisAdjust.VBOffsetOffset << ", " << ThisAdjust.VtordispOffset
 470          << ", " << ThisAdjust.StaticOffset << "}'";
 471     } else {
 472       OB << "`vtordisp{" << ThisAdjust.VtordispOffset << ", "
 473          << ThisAdjust.StaticOffset << "}'";
 474     }
 475   }
 476
 477   FunctionSignatureNode::outputPost(OB, Flags);
 478 }
 479
 480 void PointerTypeNode::outputPre(OutputBuffer &OB, OutputFlags Flags) const {
 481   if (Pointee->kind() == NodeKind::FunctionSignature) {
 482     // If this is a pointer to a function, don't output the calling convention.
 483     // It needs to go inside the parentheses.
 484     const FunctionSignatureNode *Sig =
 485         static_cast<const FunctionSignatureNode *>(Pointee);
 486     Sig->outputPre(OB, OF_NoCallingConvention);
 487   } else
 488     Pointee->outputPre(OB, Flags);
 489
 490   outputSpaceIfNecessary(OB);
 491
 492   if (Quals & Q_Unaligned)
 493     OB << "__unaligned ";
 494
 495   if (Pointee->kind() == NodeKind::ArrayType) {
 496     OB << "(";
 497   } else if (Pointee->kind() == NodeKind::FunctionSignature) {
 498     OB << "(";
 499     const FunctionSignatureNode *Sig =
 500         static_cast<const FunctionSignatureNode *>(Pointee);
 501     outputCallingConvention(OB, Sig->CallConvention);
 502     OB << " ";
 503   }
 504
 505   if (ClassParent) {
 506     ClassParent->output(OB, Flags);
 507     OB << "::";
 508   }
 509
 510   switch (Affinity) {
 511   case PointerAffinity::Pointer:
 512     OB << "*";
 513     break;
 514   case PointerAffinity::Reference:
 515     OB << "&";
 516     break;
 517   case PointerAffinity::RValueReference:
 518     OB << "&&";
 519     break;
 520   default:
 521     assert(false);
 522   }
 523   outputQualifiers(OB, Quals, false, false);
 524 }
 525
 526 void PointerTypeNode::outputPost(OutputBuffer &OB, OutputFlags Flags) const {
 527   if (Pointee->kind() == NodeKind::ArrayType ||
 528       Pointee->kind() == NodeKind::FunctionSignature)
 529     OB << ")";
 530
 531   Pointee->outputPost(OB, Flags);
 532 }
 533
 534 void TagTypeNode::outputPre(OutputBuffer &OB, OutputFlags Flags) const {
 535   if (!(Flags & OF_NoTagSpecifier)) {
 536     switch (Tag) {
 537       OUTPUT_ENUM_CLASS_VALUE(TagKind, Class, "class");
 538       OUTPUT_ENUM_CLASS_VALUE(TagKind, Struct, "struct");
 539       OUTPUT_ENUM_CLASS_VALUE(TagKind, Union, "union");
 540       OUTPUT_ENUM_CLASS_VALUE(TagKind, Enum, "enum");
 541     }
 542     OB << " ";
 543   }
 544   QualifiedName->output(OB, Flags);
 545   outputQualifiers(OB, Quals, true, false);
 546 }
 547
 548 void TagTypeNode::outputPost(OutputBuffer &OB, OutputFlags Flags) const {}
 549
 550 void ArrayTypeNode::outputPre(OutputBuffer &OB, OutputFlags Flags) const {
 551   ElementType->outputPre(OB, Flags);
 552   outputQualifiers(OB, Quals, true, false);
 553 }
 554
 555 void ArrayTypeNode::outputOneDimension(OutputBuffer &OB, OutputFlags Flags,
 556                                        Node *N) const {
 557   assert(N->kind() == NodeKind::IntegerLiteral);
 558   IntegerLiteralNode *ILN = static_cast<IntegerLiteralNode *>(N);
 559   if (ILN->Value != 0)
 560     ILN->output(OB, Flags);
 561 }
 562
 563 void ArrayTypeNode::outputDimensionsImpl(OutputBuffer &OB,
 564                                          OutputFlags Flags) const {
 565   if (Dimensions->Count == 0)
 566     return;
 567
 568   outputOneDimension(OB, Flags, Dimensions->Nodes[0]);
 569   for (size_t I = 1; I < Dimensions->Count; ++I) {
 570     OB << "][";
 571     outputOneDimension(OB, Flags, Dimensions->Nodes[I]);
 572   }
 573 }
 574
 575 void ArrayTypeNode::outputPost(OutputBuffer &OB, OutputFlags Flags) const {
 576   OB << "[";
 577   outputDimensionsImpl(OB, Flags);
 578   OB << "]";
 579
 580   ElementType->outputPost(OB, Flags);
 581 }
 582
 583 void SymbolNode::output(OutputBuffer &OB, OutputFlags Flags) const {
 584   Name->output(OB, Flags);
 585 }
 586
 587 void FunctionSymbolNode::output(OutputBuffer &OB, OutputFlags Flags) const {
 588   Signature->outputPre(OB, Flags);
 589   outputSpaceIfNecessary(OB);
 590   Name->output(OB, Flags);
 591   Signature->outputPost(OB, Flags);
 592 }
 593
 594 void VariableSymbolNode::output(OutputBuffer &OB, OutputFlags Flags) const {
 595   const char *AccessSpec = nullptr;
 596   bool IsStatic = true;
 597   switch (SC) {
 598   case StorageClass::PrivateStatic:
 599     AccessSpec = "private";
 600     break;
 601   case StorageClass::PublicStatic:
 602     AccessSpec = "public";
 603     break;
 604   case StorageClass::ProtectedStatic:
 605     AccessSpec = "protected";
 606     break;
 607   default:
 608     IsStatic = false;
 609     break;
 610   }
 611   if (!(Flags & OF_NoAccessSpecifier) && AccessSpec)
 612     OB << AccessSpec << ": ";
 613   if (!(Flags & OF_NoMemberType) && IsStatic)
 614     OB << "static ";
 615
 616   if (!(Flags & OF_NoVariableType) && Type) {
 617     Type->outputPre(OB, Flags);
 618     outputSpaceIfNecessary(OB);
 619   }
 620   Name->output(OB, Flags);
 621   if (!(Flags & OF_NoVariableType) && Type)
 622     Type->outputPost(OB, Flags);
 623 }
 624
 625 void CustomTypeNode::outputPre(OutputBuffer &OB, OutputFlags Flags) const {
 626   Identifier->output(OB, Flags);
 627 }
 628 void CustomTypeNode::outputPost(OutputBuffer &OB, OutputFlags Flags) const {}
 629
 630 void QualifiedNameNode::output(OutputBuffer &OB, OutputFlags Flags) const {
 631   Components->output(OB, Flags, "::");
 632 }
 633
 634 void RttiBaseClassDescriptorNode::output(OutputBuffer &OB,
 635                                          OutputFlags Flags) const {
 636   OB << "`RTTI Base Class Descriptor at (";
 637   OB << NVOffset << ", " << VBPtrOffset << ", " << VBTableOffset << ", "
 638      << this->Flags;
 639   OB << ")'";
 640 }
 641
 642 void LocalStaticGuardVariableNode::output(OutputBuffer &OB,
 643                                           OutputFlags Flags) const {
 644   Name->output(OB, Flags);
 645 }
 646
 647 void VcallThunkIdentifierNode::output(OutputBuffer &OB,
 648                                       OutputFlags Flags) const {
 649   OB << "`vcall'{" << OffsetInVTable << ", {flat}}";
 650 }
 651
 652 void SpecialTableSymbolNode::output(OutputBuffer &OB, OutputFlags Flags) const {
 653   outputQualifiers(OB, Quals, false, true);
 654   Name->output(OB, Flags);
 655   if (TargetName) {
 656     OB << "{for `";
 657     TargetName->output(OB, Flags);
 658     OB << "'}";
 659   }
 660 }