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
18using namespace llvm;
19using 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.
27static 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
36static 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
52static 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, Q: Mask);
61 return true;
62}
63
64static 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, Mask: Q_Const, NeedSpace: SpaceBefore);
71 SpaceBefore = outputQualifierIfPresent(OB, Q, Mask: Q_Volatile, NeedSpace: SpaceBefore);
72 SpaceBefore = outputQualifierIfPresent(OB, Q, Mask: Q_Restrict, NeedSpace: SpaceBefore);
73 size_t Pos2 = OB.getCurrentPosition();
74 if (SpaceAfter && Pos2 > Pos1)
75 OB << " ";
76}
77
78static 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
120std::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(ptr: OB.getBuffer());
126 return Owned;
127}
128
129void 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, Q: Quals, SpaceBefore: true, SpaceAfter: false);
154}
155
156void NodeArrayNode::output(OutputBuffer &OB, OutputFlags Flags) const {
157 output(OB, Flags, Separator: ", ");
158}
159
160void 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
172void 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
193void IntegerLiteralNode::output(OutputBuffer &OB, OutputFlags Flags) const {
194 if (IsNegative)
195 OB << '-';
196 OB << Value;
197}
198
199void 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
221void IdentifierNode::outputTemplateParameters(OutputBuffer &OB,
222 OutputFlags Flags) const {
223 if (!TemplateParams)
224 return;
225 OB << "<";
226 TemplateParams->output(OB, Flags);
227 OB << ">";
228}
229
230void 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
248void NamedIdentifierNode::output(OutputBuffer &OB, OutputFlags Flags) const {
249 OB << Name;
250 outputTemplateParameters(OB, Flags);
251}
252
253void 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
354void 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
364void ConversionOperatorIdentifierNode::output(OutputBuffer &OB,
365 OutputFlags Flags) const {
366 OB << "operator";
367 outputTemplateParameters(OB, Flags);
368 OB << " ";
369 TargetType->output(OB, Flags);
370}
371
372void StructorIdentifierNode::output(OutputBuffer &OB, OutputFlags Flags) const {
373 if (IsDestructor)
374 OB << "~";
375 Class->output(OB, Flags);
376 outputTemplateParameters(OB, Flags);
377}
378
379void LiteralOperatorIdentifierNode::output(OutputBuffer &OB,
380 OutputFlags Flags) const {
381 OB << "operator \"\"" << Name;
382 outputTemplateParameters(OB, Flags);
383}
384
385void 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, CC: CallConvention);
415}
416
417void 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
455void ThunkSignatureNode::outputPre(OutputBuffer &OB, OutputFlags Flags) const {
456 OB << "[thunk]: ";
457
458 FunctionSignatureNode::outputPre(OB, Flags);
459}
460
461void 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
478void 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, Flags: 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, CC: 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, Q: Quals, SpaceBefore: false, SpaceAfter: false);
522}
523
524void 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
532void 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, Q: Quals, SpaceBefore: true, SpaceAfter: false);
544}
545
546void TagTypeNode::outputPost(OutputBuffer &OB, OutputFlags Flags) const {}
547
548void ArrayTypeNode::outputPre(OutputBuffer &OB, OutputFlags Flags) const {
549 ElementType->outputPre(OB, Flags);
550 outputQualifiers(OB, Q: Quals, SpaceBefore: true, SpaceAfter: false);
551}
552
553void 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
561void ArrayTypeNode::outputDimensionsImpl(OutputBuffer &OB,
562 OutputFlags Flags) const {
563 if (Dimensions->Count == 0)
564 return;
565
566 outputOneDimension(OB, Flags, N: Dimensions->Nodes[0]);
567 for (size_t I = 1; I < Dimensions->Count; ++I) {
568 OB << "][";
569 outputOneDimension(OB, Flags, N: Dimensions->Nodes[I]);
570 }
571}
572
573void ArrayTypeNode::outputPost(OutputBuffer &OB, OutputFlags Flags) const {
574 OB << "[";
575 outputDimensionsImpl(OB, Flags);
576 OB << "]";
577
578 ElementType->outputPost(OB, Flags);
579}
580
581void SymbolNode::output(OutputBuffer &OB, OutputFlags Flags) const {
582 Name->output(OB, Flags);
583}
584
585void 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
592void 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
623void CustomTypeNode::outputPre(OutputBuffer &OB, OutputFlags Flags) const {
624 Identifier->output(OB, Flags);
625}
626void CustomTypeNode::outputPost(OutputBuffer &OB, OutputFlags Flags) const {}
627
628void QualifiedNameNode::output(OutputBuffer &OB, OutputFlags Flags) const {
629 Components->output(OB, Flags, Separator: "::");
630}
631
632void 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
640void LocalStaticGuardVariableNode::output(OutputBuffer &OB,
641 OutputFlags Flags) const {
642 Name->output(OB, Flags);
643}
644
645void VcallThunkIdentifierNode::output(OutputBuffer &OB,
646 OutputFlags Flags) const {
647 OB << "`vcall'{" << OffsetInVTable << ", {flat}}";
648}
649
650void SpecialTableSymbolNode::output(OutputBuffer &OB, OutputFlags Flags) const {
651 outputQualifiers(OB, Q: Quals, SpaceBefore: false, SpaceAfter: true);
652 Name->output(OB, Flags);
653 if (TargetName) {
654 OB << "{for `";
655 TargetName->output(OB, Flags);
656 OB << "'}";
657 }
658}
659